HiMCP

HuntX

MCP server providing direct tool-access to security-testing primitives for bug bounty hunting, including recon, request replay, IDOR/BOLA fuzzing, vulnerability detection, secrets scanning, and persistent hunt memory with confidence-scored findings.

Seq MCP Server

MCP server for querying structured logs from Datalust Seq, providing tools to search logs, retrieve recent errors, fetch events, and check health.

Purple Flea Wallet

Non-custodial HD wallet API for AI agents. Generate wallets on 6 chains (ETH, Base, SOL, BTC, TRX, XMR), check balances, send crypto, and swap cross-chain via Wagyu aggregator. 10% referral commissions.

Dovetail MCP Server

Enables AI tools to connect to the Dovetail API for accessing customer insights and research data.

Excel MCP Server

Enables conversational data analysis of Excel/CSV files through natural language queries, powered by 395 Excel functions via HyperFormula and multi-provider AI. Supports advanced analytics, bulk operations, financial modeling, and large file processing with intelligent chunking.

claude-remind-mcp

Searches your local Claude Code conversation history to recall and resume past solutions.

Red-team-mcp

An MCP server for red teaming that enables AI agents to perform port scanning, vulnerability scanning, SSH operations, and Metasploit exploitation through a unified interface.

aba-payway-mcp

Enables MCP-compatible AI tools to create checkouts, generate KHQR codes, check/list transactions, issue refunds, create payment links, and pull exchange rates via ABA Bank's PayWay API.

CommandBridge MCP

Cross-platform MCP server for policy-controlled command execution on Linux and Windows, with no SSH dependency.

aws-blackbelt-mcp-server

A Model Context Protocol (MCP) server that enables searching AWS Black Belt Online Seminars and retrieving their transcripts.

MySQL MCP Server

Enables interaction with MySQL databases via HTTP/SSE, allowing SQL query execution and table data access through the Model Context Protocol.

code-analyze-mcp

Standalone MCP server for code structure analysis using tree-sitter. Directory trees, symbol definitions, and call graphs without reading raw source files. Supports Rust, Python, Go, Java, TypeScript, Fortran, JavaScript, C/C++, and C#. Benchmarked up to 68% fewer tokens vs native tools.

CAP MCP Plugin

A CAP plugin that automatically generates MCP servers from your CAP services, transforming OData services into AI-accessible resources, tools, and prompts with minimal configuration.

TimeLiner MCP Server

An MCP server for controlling the TimeLiner project management system, enabling AI clients to manage projects, tasks, members, and more via natural language.

@droplinkperformance/bitbucket-mcp-server

Enables AI-powered pull request review and analysis for Bitbucket Cloud, plus tools to list, create, diff, comment on, and analyze PRs. Supports stdio or HTTP transports with OAuth/bearer auth and pluggable LLM providers.

discord-mcp-server

Lets any MCP-compatible AI client interact with Discord — send messages, manage channels, create webhooks, assign roles, and more.

Cars MCP Server

Okay, here's a basic example of how you might set up a simple Minecraft Protocol (MCP) server using Spring AI concepts. Keep in mind that this is a *very* high-level outline. Building a full MCP server is a complex undertaking. This example focuses on illustrating how Spring AI *could* be integrated for certain aspects, not on providing a complete, production-ready server. **Conceptual Overview** The core idea is to use Spring AI to handle certain aspects of the server logic, such as: * **Natural Language Command Processing:** Allow players to issue commands in natural language, which Spring AI can then translate into specific server actions. * **Dynamic Content Generation:** Use AI to generate quests, stories, or even world elements on the fly. * **NPC Behavior:** Control the behavior of non-player characters (NPCs) using AI models. **Simplified Example (Focusing on Command Processing)** Let's focus on the command processing aspect for this example. **1. Project Setup (Maven/Gradle)** You'll need a Spring Boot project. Here's a basic `pom.xml` (Maven) with the necessary dependencies: ```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>  <relativePath/>  </parent> <groupId>com.example</groupId> <artifactId>mcp-server</artifactId> <version>0.0.1-SNAPSHOT</version> <name>mcp-server</name> <description>Basic MCP Server with Spring AI</description> <properties> <java.version>17</java.version> <spring-ai.version>1.0.0-M2</spring-ai.version>  </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency>  <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-core</artifactId> <version>${spring-ai.version}</version> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai</artifactId> <version>${spring-ai.version}</version> </dependency>  <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.100.Final</version>  </dependency>  <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build> <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> </project> ``` **Important:** * Replace `3.2.0` and `1.0.0-M2` with the latest stable versions of Spring Boot and Spring AI, respectively. * You'll need an OpenAI API key. Set it as an environment variable or in your `application.properties` file. * This example uses Netty for handling the network communication. You could use other libraries as well. **2. `application.properties` (or `application.yml`)** ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY ``` **3. MCP Server (Simplified with Netty)** ```java package com.example.mcpserver; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder; import lombok.RequiredArgsConstructor; import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class McpServerApplication { public static void main(String[] args) { SpringApplication.run(McpServerApplication.class, args); } @Bean public CommandLineRunner run(McpServer mcpServer) { return args -> { mcpServer.start(); }; } @Bean public McpServer mcpServer(AiClient aiClient, @Value("${server.port:25565}") int port) { return new McpServer(aiClient, port); } } @RequiredArgsConstructor class McpServer { private final AiClient aiClient; private final int port; public void start() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) { ChannelPipeline p = ch.pipeline(); p.addLast(new StringDecoder(), new StringEncoder(), new McpServerHandler(aiClient)); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); // Bind and start to accept incoming connections. ChannelFuture f = b.bind(port).sync(); System.out.println("MCP Server started on port " + port); // Wait until the server socket is closed. // In this example, this does not happen, but you can do that to gracefully // shut down your server. f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } } @RequiredArgsConstructor class McpServerHandler extends ChannelInboundHandlerAdapter { private final AiClient aiClient; @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { String command = (String) msg; System.out.println("Received command: " + command); // Use Spring AI to process the command String aiResponse = processCommand(command); // Send the response back to the client ctx.writeAndFlush(aiResponse + "\n"); } private String processCommand(String command) { // Define a prompt template for command processing String promptString = "You are a Minecraft server assistant. The player said: {command}. Determine the appropriate Minecraft command and explain it to the user. If the command is not valid, respond with an error message."; PromptTemplate promptTemplate = new PromptTemplate(promptString); // Create a prompt with the player's command org.springframework.ai.prompt.Prompt prompt = promptTemplate.create(org.springframework.ai.prompt.PromptTemplate.map("command", command)); // Call the AI model String aiResponse = aiClient.generate(prompt).getGeneration().getText(); return aiResponse; } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } ``` **Explanation:** 1. **Dependencies:** The `pom.xml` includes Spring AI, Netty, and Lombok. 2. **`application.properties`:** Sets the OpenAI API key. 3. **`McpServerApplication`:** The main Spring Boot application class. It creates the `McpServer` bean and starts it when the application runs. 4. **`McpServer`:** This class uses Netty to create a simple TCP server. It listens for incoming connections on the specified port. 5. **`McpServerHandler`:** This class handles incoming messages (commands) from clients. * It receives the command as a string. * It uses Spring AI's `AiClient` to process the command. * It sends the AI-generated response back to the client. 6. **`processCommand`:** * Defines a prompt template that instructs the AI model to act as a Minecraft server assistant. * Creates a `Prompt` object with the player's command. * Calls the `AiClient` to generate a response based on the prompt. **How it Works:** 1. The server starts and listens for connections. 2. A player connects to the server. 3. The player sends a command (e.g., "I want to build a house"). 4. The `McpServerHandler` receives the command. 5. The `processCommand` method constructs a prompt for the AI model, including the player's command. 6. The `AiClient` sends the prompt to the OpenAI API. 7. The OpenAI API generates a response (e.g., "To build a house, you'll need wood, stone, and a crafting table. The command to get wood is `/give @p minecraft:oak_log 64`"). 8. The `McpServerHandler` sends the AI-generated response back to the player. **To Run:** 1. Make sure you have Java 17 or later installed. 2. Set the `spring.ai.openai.api-key` property in `application.properties` with your OpenAI API key. 3. Run the Spring Boot application. 4. Use a simple TCP client (like `netcat` or a custom client) to connect to the server on the specified port (default 25565). 5. Send commands to the server. **Important Considerations:** * **Security:** This is a *very* basic example and does not include any security measures. In a real-world MCP server, you would need to implement proper authentication, authorization, and input validation to prevent malicious attacks. * **MCP Protocol:** This example doesn't implement the full Minecraft Protocol. You would need to handle the protocol handshake, packet encoding/decoding, and other protocol-specific details. Libraries like `mc-netty` can help with this. * **Error Handling:** The error handling in this example is minimal. You should add more robust error handling to catch exceptions and provide informative error messages to the player. * **AI Model Cost:** Using OpenAI's API can incur costs. Be mindful of your usage and set up billing alerts. * **Prompt Engineering:** The quality of the AI's responses depends heavily on the prompt you provide. Experiment with different prompts to get the desired behavior. * **Rate Limiting:** The OpenAI API has rate limits. Implement rate limiting in your server to avoid exceeding these limits. * **Context Management:** For more complex interactions, you'll need to manage the context of the conversation with the player. This could involve storing the player's inventory, location, and other relevant information. **Further Development:** * **Implement the full MCP protocol:** Use a library like `mc-netty` to handle the protocol details. * **Add more AI-powered features:** * Dynamic quest generation. * NPC behavior control. * World generation. * **Improve the command processing:** * Add support for more complex commands. * Implement command validation. * Provide more helpful feedback to the player. * **Integrate with a Minecraft server API:** If you want to modify the game world directly, you'll need to integrate with a Minecraft server API like Bukkit or Spigot. **In Portuguese (Translation):** Aqui está um exemplo básico de como você pode configurar um servidor Minecraft Protocol (MCP) simples usando conceitos do Spring AI. Lembre-se de que este é um esboço *muito* geral. Construir um servidor MCP completo é uma tarefa complexa. Este exemplo se concentra em ilustrar como o Spring AI *poderia* ser integrado para certos aspectos, não em fornecer um servidor completo e pronto para produção. **Visão Geral Conceitual** A ideia central é usar o Spring AI para lidar com certos aspectos da lógica do servidor, como: * **Processamento de Comandos em Linguagem Natural:** Permitir que os jogadores emitam comandos em linguagem natural, que o Spring AI pode então traduzir em ações específicas do servidor. * **Geração Dinâmica de Conteúdo:** Usar IA para gerar missões, histórias ou até mesmo elementos do mundo em tempo real. * **Comportamento de NPCs:** Controlar o comportamento de personagens não jogáveis (NPCs) usando modelos de IA. **Exemplo Simplificado (Focando no Processamento de Comandos)** Vamos nos concentrar no aspecto do processamento de comandos para este exemplo. **1. Configuração do Projeto (Maven/Gradle)** Você precisará de um projeto Spring Boot. Aqui está um `pom.xml` básico (Maven) com as dependências necessárias: ```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>  <relativePath/>  </parent> <groupId>com.example</groupId> <artifactId>mcp-server</artifactId> <version>0.0.1-SNAPSHOT</version> <name>mcp-server</name> <description>Basic MCP Server with Spring AI</description> <properties> <java.version>17</java.version> <spring-ai.version>1.0.0-M2</spring-ai.version>  </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency>  <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-core</artifactId> <version>${spring-ai.version}</version> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai</artifactId> <version>${spring-ai.version}</version> </dependency>  <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.100.Final</version>  </dependency>  <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build> <repositories> <repository> <id>spring-milestones</id> <name>Spring Milestones</name> <url>https://repo.spring.io/milestone</url> <snapshots> <enabled>false</enabled> </snapshots> </repository> </repositories> </project> ``` **Importante:** * Substitua `3.2.0` e `1.0.0-M2` pelas versões estáveis mais recentes do Spring Boot e Spring AI, respectivamente. * Você precisará de uma chave de API do OpenAI. Defina-a como uma variável de ambiente ou no seu arquivo `application.properties`. * Este exemplo usa Netty para lidar com a comunicação de rede. Você pode usar outras bibliotecas também. **2. `application.properties` (ou `application.yml`)** ```properties spring.ai.openai.api-key=SUA_CHAVE_API_OPENAI ``` **3. Servidor MCP (Simplificado com Netty)** ```java package com.example.mcpserver; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.SocketChannel; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.codec.string.StringDecoder; import io.netty.handler.codec.string.StringEncoder; import lombok.RequiredArgsConstructor; import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.annotation.Bean; @SpringBootApplication public class McpServerApplication { public static void main(String[] args) { SpringApplication.run(McpServerApplication.class, args); } @Bean public CommandLineRunner run(McpServer mcpServer) { return args -> { mcpServer.start(); }; } @Bean public McpServer mcpServer(AiClient aiClient, @Value("${server.port:25565}") int port) { return new McpServer(aiClient, port); } } @RequiredArgsConstructor class McpServer { private final AiClient aiClient; private final int port; public void start() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap b = new ServerBootstrap(); b.group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) { ChannelPipeline p = ch.pipeline(); p.addLast(new StringDecoder(), new StringEncoder(), new McpServerHandler(aiClient)); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); // Bind and start to accept incoming connections. ChannelFuture f = b.bind(port).sync(); System.out.println("Servidor MCP iniciado na porta " + port); // Wait until the server socket is closed. // In this example, this does not happen, but you can do that to gracefully // shut down your server. f.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } } @RequiredArgsConstructor class McpServerHandler extends ChannelInboundHandlerAdapter { private final AiClient aiClient; @Override public void channelRead(ChannelHandlerContext ctx, Object msg) { String command = (String) msg; System.out.println("Comando recebido: " + command); // Use Spring AI to process the command String aiResponse = processCommand(command); // Send the response back to the client ctx.writeAndFlush(aiResponse + "\n"); } private String processCommand(String command) { // Define a prompt template for command processing String promptString = "Você é um assistente de servidor Minecraft. O jogador disse: {command}. Determine o comando Minecraft apropriado e explique-o ao usuário. Se o comando não for válido, responda com uma mensagem de erro."; PromptTemplate promptTemplate = new PromptTemplate(promptString); // Create a prompt with the player's command org.springframework.ai.prompt.Prompt prompt = promptTemplate.create(org.springframework.ai.prompt.PromptTemplate.map("command", command)); // Call the AI model String aiResponse = aiClient.generate(prompt).getGeneration().getText(); return aiResponse; } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); ctx.close(); } } ``` **Explicação:** 1. **Dependências:** O `pom.xml` inclui Spring AI, Netty e Lombok. 2. **`application.properties`:** Define a chave de API do OpenAI. 3. **`McpServerApplication`:** A classe principal da aplicação Spring Boot. Ela cria o bean `McpServer` e o inicia quando a aplicação é executada. 4. **`McpServer`:** Esta classe usa Netty para criar um servidor TCP simples. Ele escuta as conexões de entrada na porta especificada. 5. **`McpServerHandler`:** Esta classe lida com as mensagens de entrada (comandos) dos clientes. * Ele recebe o comando como uma string. * Ele usa o `AiClient` do Spring AI para processar o comando. * Ele envia a resposta gerada pela IA de volta ao cliente. 6. **`processCommand`:** * Define um modelo de prompt que instrui o modelo de IA a atuar como um assistente de servidor Minecraft. * Cria um objeto `Prompt` com o comando do jogador. * Chama o `AiClient` para gerar uma resposta com base no prompt. **Como Funciona:** 1. O servidor inicia e escuta as conexões. 2. Um jogador se conecta ao servidor. 3. O jogador envia um comando (por exemplo, "Eu quero construir uma casa"). 4. O `McpServerHandler` recebe o comando. 5. O método `processCommand` constrói um prompt para o modelo de IA, incluindo o comando do jogador. 6. O `AiClient` envia o prompt para a API do OpenAI. 7. A API do OpenAI gera uma resposta (por exemplo, "Para construir uma casa, você precisará de madeira, pedra e uma mesa de trabalho. O comando para obter madeira é `/give @p minecraft:oak_log 64`"). 8. O `McpServerHandler` envia a resposta gerada pela IA de volta ao jogador. **Para Executar:** 1. Certifique-se de ter o Java 17 ou posterior instalado. 2. Defina a propriedade `spring.ai.openai.api-key` em `application.properties` com sua chave de API do OpenAI. 3. Execute a aplicação Spring Boot. 4. Use um cliente TCP simples (como `netcat` ou um cliente personalizado) para se conectar ao servidor na porta especificada (padrão 25565). 5. Envie comandos para o servidor. **Considerações Importantes:** * **Segurança:** Este é um exemplo *muito* básico e não inclui nenhuma medida de segurança. Em um servidor MCP real, você precisaria implementar autenticação, autorização e validação de entrada adequadas para evitar ataques maliciosos. * **Protocolo MCP:** Este exemplo não implementa o protocolo Minecraft completo. Você precisaria lidar com o handshake do protocolo, codificação/decodificação de pacotes e outros detalhes específicos do protocolo. Bibliotecas como `mc-netty` podem ajudar com isso. * **Tratamento de Erros:** O tratamento de erros neste exemplo é mínimo. Você deve adicionar um tratamento de erros mais robusto para capturar exceções e fornecer mensagens de erro informativas ao jogador. * **Custo do Modelo de IA:** O uso da API do OpenAI pode gerar custos. Esteja atento ao seu uso e configure alertas de faturamento. * **Engenharia de Prompt:** A qualidade das respostas da IA depende muito do prompt que você fornece. Experimente diferentes prompts para obter o comportamento desejado. * **Limitação de Taxa:** A API do OpenAI tem limites de taxa. Implemente a limitação de taxa em seu servidor para evitar exceder esses limites. * **Gerenciamento de Contexto:** Para interações mais complexas, você precisará gerenciar o contexto da conversa com o jogador. Isso pode envolver o armazenamento do inventário, localização e outras informações relevantes do jogador. **Desenvolvimento Adicional:** * **Implemente o protocolo MCP completo:** Use uma biblioteca como `mc-netty` para lidar com os detalhes do protocolo. * **Adicione mais recursos alimentados por IA:** * Geração dinâmica de missões. * Controle do comportamento de NPCs. * Geração de mundo. * **Melhore o processamento de comandos:** * Adicione suporte para comandos mais complexos. * Implemente a validação de comandos. * Forneça feedback mais útil ao jogador. * **Integre com uma API de servidor Minecraft:** Se você quiser modificar o mundo do jogo diretamente, precisará se integrar a uma API de servidor Minecraft como Bukkit ou Spigot. This provides a starting point. Remember to adapt and expand upon this example to create a more complete and functional MCP server. Good luck!

unstuck-mcp

Prevents coding agents from repeatedly attempting the same failed fix by tracking attempts and blocking further fixes until the agent uses its own web search tool.

wows-remote-agent

MCP server to remotely monitor and control a Windows PC running World of Warships via Tailscale, enabling status checks, screenshots, game launch, and calibrated menu workflows with safety limits.

A MCP server for Godot RAG

Este servidor MCP é usado para fornecer documentação do Godot ao modelo RAG do Godot.

Commodore 64 Ultimate MCP Server

Enables AI assistants to control Commodore 64 Ultimate hardware via REST API, supporting program execution, memory operations, disk management, audio playback, and device configuration through natural language commands.

FFmpeg MCP

Enables video and audio processing through FFmpeg, supporting format conversion, compression, trimming, audio extraction, frame extraction, video merging, and subtitle burning through natural language commands.

mcp-guard

Zero-dependency local proxy that wraps any MCP server to redact secrets, strip hidden-Unicode prompt injection, and block writes to protected paths like ~/.ssh and .env.

reddit-trends-mcp

Provides Reddit discussion volume trends, growth rates, and top trending topics for any keyword, accessible via MCP tools and Python client.

Mavis MCP Server

Exposes the Mavis multi-agent system as an MCP server, enabling Claude Code and other MCP clients to manage sessions, spawn agents, orchestrate team tasks, and perform code reviews, memory searches, and cron scheduling via natural language.

GTA V Browser MCP Server

Enables browsing and extracting files from Grand Theft Auto V's RPF archives, supporting RPF7 format with AES encryption and nested archives.

Somnia MCP Server

Enables AI agents to interact with the Somnia blockchain network, including documentation search, blockchain queries, wallet management, cryptographic signing, and on-chain operations.

transcribeMCP

MCP server for GovTech's Transcribe speech-to-text service, enabling audio upload, batch transcription, summaries, minutes, sections, notes, and transcript Q&A.

Simple MCP Search Server

MCP SSH Server

Enables Claude Code to control remote servers via SSH for automated deployment, testing, and operations, including command execution and file transfer.

Discover Awesome MCP Servers

Extend your agent with 84,517 capabilities via MCP servers.