Discover Awesome MCP Servers

Washington Law MCP Server

Provides offline access to Washington State's Revised Code of Washington (RCW) and Washington Administrative Code (WAC) for AI agents. Enables fast retrieval, full-text search, and navigation of all Washington state laws through natural language queries.

io.github.DiegoBr4nd/godot-gut-mcp

Enables AI assistants to run Godot unit tests using GUT and read results in a structured format

Reddit MCP

Enables browsing, searching, and reading Reddit posts, comments, and subreddits through Reddit's API using PRAW.

MCP Client-Server Sandbox for LLM Augmentation

LLM推論（ローカルまたはクラウド）をMCPクライアント-サーバーで拡張するための完全なサンドボックスです。MCPサーバーの検証とエージェント評価のための低摩擦テストベッドです。

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.

Quack MCP Server

A continuous integration server that automates Python code analysis, providing linting and static type checking tools for quality assurance.

Email Sender MCP Server

Enables sending emails through SMTP with support for multiple recipients, attachments, CC/BCC, and both plain text and HTML formats. Includes preset configurations for common email providers like Gmail, QQ, Outlook, and 163.

L.O.G. (Latent Orchestration Gateway)

A privacy-first memory layer that pseudonymizes sensitive data locally before sharing a 'Working-Fiction' version with external AI agents. It enables secure agentic workflows by ensuring personally identifiable information never leaves the user's sovereign hardware.

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.

A MCP server for Godot RAG

このMCPサーバーは、Godot RAGモデルにGodotドキュメントを提供するために使用されます。

Applitools MCP Server

Enables AI assistants to set up, manage, and analyze visual tests using Applitools Eyes within Playwright JavaScript and TypeScript projects. It supports adding visual checkpoints, configuring cross-browser testing via Ultrafast Grid, and retrieving structured test results.

discord-mcp-server

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

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.

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.

Slack Universal MCP Server

Provides a standardized interface for interacting with Slack's tools and services through a unified API, enabling integration with MCP-compliant applications.

Bitbucket Cloud MCP Server

Enables AI assistants to read Bitbucket Cloud pull requests and diffs through natural conversation.

MCP SSH Server

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

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.

ETH Price Current Server

A minimal Model Context Protocol (MCP) server that fetches the current Ethereum (ETH) price in USD. Data source: the public CoinGecko API (no API key required). This MCP is designed to simulate malicious behavior, specifically an attempt to mislead LLM to return incorrect results.

Teable MCP Server

Connects Teable no-code databases to LLMs, enabling AI agents to query records, explore schema structures, retrieve data history, and interact with spaces, bases, tables, and views using natural language.

bq_mcp_server

A Python MCP server that retrieves and caches BigQuery metadata (datasets, tables, columns) and enables secure SQL query execution with cost control, file export, and keyword search.

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.

mcp-server-toolkit

Production-ready MCP server starter with authentication, observability, and a plugin system for building and deploying MCP servers quickly.

NOUZ MCP Server

MCP Server for local knowledge management. Semantic + keywords + tags

Awesome MCP Servers

Model Context Protocol (MCP) サーバーの包括的なコレクション

ha-mcp

A self-hosted MCP server for Home Assistant that exposes full control over entity states, service calls, history, templates, and areas via local stdio, enabling AI assistants to manage your smart home.

Bureau of Economic Analysis (BEA) MCP Server

Provides access to comprehensive U.S. economic data including GDP, personal income, and regional statistics via the Bureau of Economic Analysis API. It enables users to query datasets and retrieve specific economic indicators for states, counties, and industries through natural language.