Discover Awesome MCP Servers

Agent Collaboration MCP Server

Enables AI agents to orchestrate a team of sub-agents through tmux sessions for complex task delegation and parallel implementation. It provides tools for launching agents, monitoring their real-time status, and managing communication between them.

LogixDesigner-MCP

MCP server wrapping the Rockwell Automation Logix Designer SDK to open ACD files, export to L5K/L5X, read rung logic, and enumerate tags and program structure via typed MCP tools, bridged from Windows to Linux via Cloudflare Tunnel.

SQLite Project Memory MCP

A graph-friendly relational server that stores project memory, tasks, and metadata in a centralized SQLite database as the authoritative source of truth. It enables AI agents to manage complex project states through entity-relationship modeling and can generate human-readable markdown views on demand.

MCP Firebird

Firebird SQL データベース向けに Anthropic の Model Context Protocol (MCP) を実装したサーバー。Claude などの LLM が自然言語を通じて Firebird データベース内のデータに安全にアクセス、分析、操作することを可能にする。

CloakMCP

An MCP server that provides LLMs with stealth browser automation capabilities via CloakBrowser to bypass bot detection services like Cloudflare and reCAPTCHA. It supports full page interaction, content extraction, and human-like behavior through 30 specialized tools.

agent-recall

Enables persistent memory for AI coding agents, allowing them to remember people, decisions, and context across sessions through a knowledge graph and automated briefings.

ToolMux

Aggregates multiple MCP servers via a single interface with token optimization and multiple operating modes (Gateway, Meta, Proxy, Search, Code).

Pangolinfo Amazon Data MCP

Enables AI agents to access Amazon commerce intelligence, WIPO design-patent data, Google Trends, and local market data through 19 business data tools via a stdio bridge to a hosted MCP server.

Radar de Riesgo de Devolución

MCP server for e-commerce return risk analysis, providing tools to calculate customer risk profiles, compare segments, and identify risk factors, with memory for contextual conversations.

ytmcp

Enables AI assistants to fetch YouTube video transcripts with precise timestamps, multi-language support, and time-range filtering.

agentguard

Enables scanning of AI agent code for security vulnerabilities such as prompt injection, tool abuse, and data exfiltration, directly from MCP-compatible clients like Claude Code.

Amazon Product Search MCP

Enables AI-powered Amazon product searches and recommendations by integrating the Amazon API with Hugging Face models. It allows users to filter products by price and specific features to receive tailored shopping suggestions.

paraph-mcp

MCP server for the Paraph e-signature API that enables AI tools to fill PDF forms and manage electronic signing workflows. It provides tools for template management, document filling, sending signing requests, and tracking signing progress.

readypermit-mcp

AI-powered property intelligence for instant zoning analysis, buildability assessments, ADU eligibility, flood risk, and development feasibility reports for any US address.

IoT Device Management MCP Server

Enables registration, monitoring, and control of IoT devices via AI agents, with local storage and no cloud API key required.

phase8-mcp

MCP server for the Korg Phase 8 acoustic synthesizer that enables triggering resonators, controlling per-resonator knobs, and modulating global parameters over USB MIDI.

ellmos-servercommander-mcp

Alpha MCP server for server operations enabling deployment dry-runs, mail readiness diagnostics, access-log analysis, and HTTP health checks.

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.

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.

discord-mcp-server

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

reddit-trends-mcp

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

A MCP server for Godot RAG

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

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.

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.

mcp-proxy

A self-hosted, OAuth-fronted MCP proxy that lets Claude custom connectors reach RapidAPI's MCP endpoints by injecting API credentials, with per-upstream tool filtering and rate limiting.

personality-test-mcp

Enables AI models to administer personality tests, score responses, and provide personality type assessments, with optional integration with Ollama for personalized AI interactions.

Kolosal Vision MCP

Provides AI-powered image analysis and OCR capabilities using the Kolosal Vision API. Supports analyzing images from URLs, local files, or base64 data with natural language queries for object detection, scene description, text extraction, and visual assessment.

Dovetail MCP Server

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