Discover Awesome MCP Servers

MCP OCI Logan Server

Connects Claude to OCI Logging Analytics for natural language querying and analysis of security logs, including detection catalog, MITRE ATT&CK integration, and cross-log correlation.

MCP Code Reviewer

Enables AI-powered code review and improvement, including analysis, refactoring suggestions, and automatic test generation, with an optional agentic loop for iterative refinement.

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.

Zuar Portal Blocks MCP Server

Enables Claude to build and manage Zuar Portal HTML blocks through the Portal REST API, including discovering datasources, previewing data, and performing CRUD operations on blocks.

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.

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.

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.

@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.

reddit-trends-mcp

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

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.

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.

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 how Spring AI could *potentially* be integrated for certain aspects, like handling player commands or generating content. **Disclaimer:** This is a conceptual example. You'll need to adapt it significantly based on your specific needs and the actual Minecraft protocol implementation you choose. Also, Spring AI is primarily designed for AI interactions, not for low-level network protocol handling. The integration here is more about using AI for specific server features. **Conceptual Architecture** 1. **MCP Server Core:** Handles the raw network communication with Minecraft clients, packet parsing, and basic game logic. This part is *not* directly related to Spring AI. You'll need a library or framework for this (e.g., a custom implementation or a library like `minecraft-server-util` or similar). 2. **Command Handling (Potential Spring AI Integration):** Instead of hardcoding command logic, you could use Spring AI to interpret player commands and generate responses. 3. **Content Generation (Potential Spring AI Integration):** You could use Spring AI to generate descriptions of the world, create quests, or even generate simple structures. **Simplified Code Example (Illustrative)** ```java // Dependencies (pom.xml - simplified) // You'll need to add the actual Minecraft protocol library // and Spring AI dependencies. This is just a placeholder. /* <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-openai</artifactId> // Or your preferred AI provider <version>0.8.0</version> // Check for the latest version </dependency> <dependency> <groupId>org.springframework.ai</groupId> <artifactId>spring-ai-spring-boot-starter</artifactId> <version>0.8.0</version> // Check for the latest version </dependency> // Minecraft protocol library (replace with actual dependency) // <dependency> ... </dependency> </dependencies> */ import org.springframework.ai.client.AiClient; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.stereotype.Component; import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; @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 private final ExecutorService executor = Executors.newFixedThreadPool(10); // Thread pool private final CommandHandler commandHandler; @Autowired public MinecraftServer(CommandHandler commandHandler) { this.commandHandler = commandHandler; } public void start() throws IOException { 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: " + clientSocket.getInetAddress().getHostAddress()); executor.submit(new ClientHandler(clientSocket, commandHandler)); // Pass commandHandler } } // Start the server after the Spring context is initialized @org.springframework.boot.context.event.EventListener(org.springframework.context.event.ContextRefreshedEvent.class) public void onApplicationEvent(org.springframework.context.event.ContextRefreshedEvent event) { try { start(); } catch (IOException e) { System.err.println("Error starting server: " + e.getMessage()); } } } class ClientHandler implements Runnable { private final Socket clientSocket; private final CommandHandler commandHandler; public ClientHandler(Socket clientSocket, CommandHandler commandHandler) { this.clientSocket = clientSocket; this.commandHandler = commandHandler; } @Override public void run() { try { // **IMPORTANT:** This is where you'd handle the Minecraft protocol. // Read packets from the client, parse them, and respond accordingly. // This example just reads lines from the client (for simplicity). java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.InputStreamReader(clientSocket.getInputStream())); java.io.PrintWriter writer = new java.io.PrintWriter(clientSocket.getOutputStream(), true); String inputLine; while ((inputLine = reader.readLine()) != null) { System.out.println("Received from client: " + inputLine); // **Command Handling using Spring AI** String response = commandHandler.handleCommand(inputLine); writer.println(response); // Send response back to the client } clientSocket.close(); System.out.println("Client disconnected: " + clientSocket.getInetAddress().getHostAddress()); } catch (IOException e) { System.err.println("Error handling client: " + e.getMessage()); } } } @Component class CommandHandler { private final AiClient aiClient; @Autowired public CommandHandler(AiClient aiClient) { this.aiClient = aiClient; } public String handleCommand(String command) { // Use Spring AI to interpret the command and generate a response. // Example: String prompt = "You are a helpful Minecraft server assistant. The player said: " + command + ". Respond in a way that is helpful and appropriate for a Minecraft server."; String response = aiClient.generate(prompt); return response; } } ``` **Explanation and Key Points:** 1. **Dependencies:** You'll need to add the Spring AI dependencies (as shown in the `pom.xml` comment). Crucially, you *also* need a library for handling the Minecraft protocol itself. There isn't a single, universally recommended library; you'll need to research and choose one that suits your needs. 2. **`MinecraftServerApplication`:** A standard Spring Boot application entry point. 3. **`MinecraftServer`:** * Creates a `ServerSocket` to listen for incoming connections on the default Minecraft port (25565). * Uses an `ExecutorService` to handle multiple client connections concurrently. * The `start()` method is called after the Spring context is initialized using `@org.springframework.boot.context.event.EventListener`. * It accepts client connections and creates a `ClientHandler` for each. 4. **`ClientHandler`:** * This is the *most important* part for handling the Minecraft protocol. The example code *only* reads lines from the client. In a real server, you would: * Read raw bytes from the `InputStream`. * Parse the bytes according to the Minecraft protocol specification. * Determine the type of packet received. * Extract the data from the packet. * Perform the appropriate action based on the packet type (e.g., handle player movement, chat messages, block placement, etc.). * Send response packets back to the client. * The `commandHandler.handleCommand(inputLine)` is where the AI integration happens. 5. **`CommandHandler`:** * This class uses Spring AI's `AiClient` to process player commands. * It constructs a prompt that includes the player's command and a description of the AI's role. * It sends the prompt to the AI and returns the generated response. **How to Run:** 1. **Set up Spring AI:** Configure your Spring AI provider (e.g., OpenAI) with your API key in your `application.properties` or `application.yml` file. For example: ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY ``` 2. **Add Minecraft Protocol Library:** Find and add a suitable Minecraft protocol library to your project's dependencies. 3. **Run the Application:** Run the `MinecraftServerApplication` as a standard Spring Boot application. **Important Considerations and Next Steps:** * **Minecraft Protocol:** The biggest challenge is implementing the Minecraft protocol correctly. This is a complex binary protocol. You'll need to study the protocol specification and use a library or write your own code to handle it. * **Security:** Security is critical for a Minecraft server. Implement proper authentication, authorization, and anti-cheat measures. * **Performance:** Optimize your server for performance, especially if you plan to support a large number of players. Consider using asynchronous I/O and efficient data structures. * **Error Handling:** Implement robust error handling to prevent crashes and provide informative error messages. * **World Generation:** You'll need to implement world generation logic. You could potentially use Spring AI to generate interesting terrain features or structures, but this would be a more advanced project. * **Game Logic:** Implement the core game logic, such as player movement, item management, combat, and crafting. * **Plugin API:** Consider creating a plugin API to allow other developers to extend your server's functionality. **Spanish Translation of Key Concepts:** * **Minecraft Protocol (MCP):** Protocolo de Minecraft (MCP) * **Server:** Servidor * **Client:** Cliente * **Packet:** Paquete * **Command:** Comando * **AI (Artificial Intelligence):** IA (Inteligencia Artificial) * **Spring AI:** Spring AI * **Prompt:** Indicación, Instrucción * **Response:** Respuesta * **World Generation:** Generación del Mundo * **Game Logic:** Lógica del Juego * **Authentication:** Autenticación * **Authorization:** Autorización * **Anti-Cheat:** Anti-Trampas * **Plugin API:** API de Plugins This example provides a starting point. Building a functional Minecraft server is a significant project that requires a deep understanding of the Minecraft protocol and server-side programming. Good luck!

MCP Server for Odoo

Enables AI assistants to interact with Odoo ERP systems through natural language, allowing users to search, create, update, and manage business records like customers, products, and invoices across any Odoo instance.

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 se utiliza para proporcionar documentación de Godot al modelo RAG de Godot.

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.

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.

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.

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.