Discover Awesome MCP Servers

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 an MCP (Minecraft Protocol) server integrated with Spring AI, along with explanations to help you understand the code and concepts. This is a simplified example to illustrate the core ideas. A real-world MCP server is significantly more complex. **Conceptual Overview** 1. **MCP Server:** This is the core of your Minecraft server. It listens for incoming connections from Minecraft clients, handles authentication, and manages game logic. We'll use a very basic socket server for demonstration. 2. **Spring AI:** This framework provides abstractions for interacting with AI models (like large language models). We'll use it to process player commands or generate content. 3. **Integration:** The MCP server receives a command from a player. It passes this command to Spring AI for processing. The AI generates a response, and the MCP server sends that response back to the player. **Code Example (Java with Spring Boot)** ```java // build.gradle.kts (or pom.xml) // Add these dependencies: // implementation("org.springframework.boot:spring-boot-starter-web") // implementation("org.springframework.ai:spring-ai-openai-spring-boot-starter:0.8.0") // Or the latest version // implementation("org.springframework.ai:spring-ai-spring-boot-starter:0.8.0") // Core Spring AI // implementation("org.springframework.boot:spring-boot-starter-websocket") // For potential WebSocket communication // implementation("org.springframework.boot:spring-boot-starter-integration") // For integration components // implementation("org.slf4j:slf4j-api") // Logging // runtimeOnly("ch.qos.logback:logback-classic") // Logging implementation import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.ai.client.AiClient; import org.springframework.ai.client.AiResponse; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Autowired; 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; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.PrintWriter; import java.net.ServerSocket; import java.net.Socket; import java.util.HashMap; import java.util.Map; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @SpringBootApplication public class McpAiServerApplication { private static final Logger logger = LoggerFactory.getLogger(McpAiServerApplication.class); @Autowired private AiClient aiClient; @Value("${mcp.server.port:25565}") // Default Minecraft port private int serverPort; @Value("${spring.ai.prompt.template:You are a helpful Minecraft assistant. Respond to the user's command: {command}}") private String promptTemplateString; public static void main(String[] args) { SpringApplication.run(McpAiServerApplication.class, args); } @Bean public CommandLineRunner commandLineRunner() { return args -> { ExecutorService executor = Executors.newFixedThreadPool(10); // Thread pool for handling clients try (ServerSocket serverSocket = new ServerSocket(serverPort)) { logger.info("MCP Server started on port: {}", serverPort); while (true) { Socket clientSocket = serverSocket.accept(); logger.info("Client connected: {}", clientSocket.getInetAddress().getHostAddress()); executor.submit(new ClientHandler(clientSocket, aiClient, promptTemplateString)); } } catch (IOException e) { logger.error("Server exception: {}", e.getMessage(), e); } finally { executor.shutdown(); } }; } private static class ClientHandler implements Runnable { private final Socket clientSocket; private final AiClient aiClient; private final String promptTemplateString; public ClientHandler(Socket socket, AiClient aiClient, String promptTemplateString) { this.clientSocket = socket; this.aiClient = aiClient; this.promptTemplateString = promptTemplateString; } @Override public void run() { try ( PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream())) ) { String inputLine; while ((inputLine = in.readLine()) != null) { logger.info("Received command: {}", inputLine); // Process the command with Spring AI String aiResponse = processCommandWithAI(inputLine); // Send the AI response back to the client out.println(aiResponse); } } catch (IOException e) { logger.error("Client handler exception: {}", e.getMessage(), e); } finally { try { clientSocket.close(); logger.info("Client disconnected: {}", clientSocket.getInetAddress().getHostAddress()); } catch (IOException e) { logger.error("Error closing socket: {}", e.getMessage(), e); } } } private String processCommandWithAI(String command) { PromptTemplate promptTemplate = new PromptTemplate(promptTemplateString); Map<String, Object> model = new HashMap<>(); model.put("command", command); String prompt = promptTemplate.render(model); AiResponse response = aiClient.generate(prompt); return response.getGeneration().getText(); } } } ``` **Explanation:** 1. **Dependencies:** The `build.gradle.kts` (or `pom.xml`) file includes the necessary Spring Boot, Spring AI, and logging dependencies. Make sure you have these in your project. The `spring-ai-openai-spring-boot-starter` is crucial if you're using OpenAI. If you're using a different AI provider, include the appropriate starter. 2. **`McpAiServerApplication`:** * This is the main Spring Boot application class. * `@SpringBootApplication`: Marks this as a Spring Boot application. * `@Autowired AiClient aiClient`: Injects the `AiClient` bean, which is configured by Spring AI to interact with your chosen AI model. You'll need to configure your `application.properties` or `application.yml` file with your AI provider's API key (see below). * `@Value("${mcp.server.port:25565}")`: Injects the server port from the application properties. The default value is 25565 (the standard Minecraft port). * `@Value("${spring.ai.prompt.template: ...}")`: Injects the prompt template from the application properties. This allows you to customize the prompt sent to the AI model. * `commandLineRunner()`: This `CommandLineRunner` bean is executed after the application starts. It contains the main server logic. * `ExecutorService`: A thread pool is used to handle multiple client connections concurrently. * `ServerSocket`: Listens for incoming connections on the specified port. * `ClientHandler`: A `Runnable` class that handles communication with a single client. It's submitted to the `ExecutorService` for execution. 3. **`ClientHandler`:** * `run()`: This method is executed in a separate thread for each client. * `PrintWriter` and `BufferedReader`: Used for sending and receiving data from the client. * The `while` loop reads commands from the client. * `processCommandWithAI()`: This method takes the command, constructs a prompt using the `PromptTemplate`, and sends it to the AI model using the `AiClient`. It then returns the AI's response. * The AI's response is sent back to the client. * The `finally` block ensures that the socket is closed when the client disconnects. 4. **`processCommandWithAI()`:** * `PromptTemplate`: Creates a prompt template from the configured string. * `Map<String, Object> model`: Creates a map to hold the command that will be inserted into the prompt template. * `promptTemplate.render(model)`: Renders the prompt template with the command. * `aiClient.generate(prompt)`: Sends the prompt to the AI model and receives a response. * `response.getGeneration().getText()`: Extracts the text from the AI's response. **Configuration (application.properties or application.yml)** You'll need to configure your Spring AI provider in your `application.properties` or `application.yml` file. Here's an example for OpenAI: ```properties # application.properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY spring.ai.openai.chat.options.model=gpt-3.5-turbo # Or gpt-4, etc. mcp.server.port=25565 spring.ai.prompt.template=You are a helpful Minecraft assistant. Respond to the user's command: {command} ``` Or, in `application.yml`: ```yaml spring: ai: openai: api-key: YOUR_OPENAI_API_KEY chat: options: model: gpt-3.5-turbo # Or gpt-4, etc. mcp: server: port: 25565 spring: ai: prompt: template: You are a helpful Minecraft assistant. Respond to the user's command: {command} ``` **Important Notes:** * **Replace `YOUR_OPENAI_API_KEY` with your actual OpenAI API key.** You can get an API key from the OpenAI website. * **Error Handling:** This example has basic error handling, but you'll need to add more robust error handling for a production environment. Consider handling exceptions related to network connections, AI API calls, and invalid commands. * **Security:** This example doesn't include any security measures. In a real-world server, you'll need to implement authentication and authorization to protect your server from unauthorized access. * **Minecraft Protocol:** This example uses a very simplified text-based protocol. The real Minecraft protocol is binary and much more complex. You'll need to use a library like `mcprotocollib` or similar to handle the actual Minecraft protocol. * **AI Cost:** Using AI models can be expensive. Be mindful of your API usage and costs. * **Rate Limiting:** AI providers often have rate limits. Implement rate limiting in your server to avoid exceeding these limits. * **Prompt Engineering:** The quality of the AI's responses depends heavily on the prompt you provide. Experiment with different prompts to get the best results. * **Asynchronous Processing:** For a more responsive server, consider using asynchronous processing (e.g., Spring's `@Async` annotation or Reactive Streams) to handle AI requests in the background. This will prevent the server from blocking while waiting for the AI to respond. * **WebSocket:** For real-time communication with the client, consider using WebSockets instead of plain sockets. Spring Boot provides excellent support for WebSockets. **How to Run:** 1. Make sure you have Java and Maven or Gradle installed. 2. Create a new Spring Boot project. 3. Add the dependencies to your `build.gradle.kts` or `pom.xml` file. 4. Create the `McpAiServerApplication` class. 5. Configure your `application.properties` or `application.yml` file with your OpenAI API key and other settings. 6. Run the application. **Testing:** You can test the server using a simple telnet client or a custom Minecraft client that sends text-based commands. For example, you could use `telnet localhost 25565` and then type commands like "What is the recipe for a wooden pickaxe?" **Next Steps:** 1. **Implement the Minecraft Protocol:** Use a library like `mcprotocollib` to handle the actual Minecraft protocol. 2. **Add Authentication:** Implement authentication to verify the identity of players. 3. **Implement Game Logic:** Add game logic to handle player actions, world generation, and other game-related tasks. 4. **Improve AI Integration:** Experiment with different prompts and AI models to improve the quality of the AI's responses. 5. **Add a User Interface:** Create a user interface for managing the server and interacting with the AI. This example provides a basic foundation for building an MCP server with Spring AI. You'll need to expand on this example to create a fully functional server. Good luck! **Japanese Translation of Key Concepts:** * **MCP (Minecraft Protocol):** Minecraftプロトコル * **Spring AI:** Spring AI (スプリングAI) * **AI Model:** AIモデル * **Prompt:** プロンプト * **Server:** サーバー * **Client:** クライアント * **API Key:** APIキー * **Authentication:** 認証 (にんしょう) * **Authorization:** 認可 (にんか) * **Game Logic:** ゲームロジック * **Thread Pool:** スレッドプール * **Socket:** ソケット * **Dependency:** 依存関係 (いぞんかんけい) * **Configuration:** 設定 (せってい) * **Error Handling:** エラー処理 (しょり) * **Asynchronous Processing:** 非同期処理 (ひどうきしょり) * **Rate Limiting:** レート制限 (せいげん) This should give you a good starting point. Remember to adapt the code and configuration to your specific needs and AI provider. Let me know if you have any more questions.

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

このMCPサーバーは、Godot RAGモデルに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.

MCP SSH Server

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