Discover Awesome MCP Servers

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.

Interzoid Weather City API MCP Server

An MCP server that provides access to the Interzoid GetWeatherCity API, allowing users to retrieve weather information for specified cities through natural language interactions.

google-spreadsheet-mcp

MCP server enabling AI agents to read, write, and manage Google Sheets, including sheet manipulation, row/column operations, dropdowns, checkboxes, and conditional formatting.

Civil3D MCP Server

Enables AI assistants to interact with Autodesk Civil 3D, allowing them to retrieve project data, create/modify/delete drawing elements, and execute code to automate Civil 3D operations.

MCP Firebird

Sebuah server yang mengimplementasikan Protokol Konteks Model (MCP) dari Anthropic untuk basis data Firebird SQL, memungkinkan Claude dan LLM lainnya untuk mengakses, menganalisis, dan memanipulasi data dalam basis data Firebird secara aman melalui bahasa alami.

claude-memory

Cross-machine memory system for Claude Code that records sessions as searchable markdown, syncs across machines via Git, and exposes full-text search, semantic search, session summarization, and a knowledge graph through an MCP server.

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.

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.

ToolMux

Aggregates multiple MCP servers via a single interface with token optimization and multiple operating modes (Gateway, Meta, Proxy, Search, 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.

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.

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.

ytmcp

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

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.

reddit-trends-mcp

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

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

Server MCP ini digunakan untuk menyediakan dokumentasi Godot ke model Godot RAG.

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.

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. This is a conceptual outline and requires significant further development to be a fully functional server. It focuses on integrating Spring AI for potential AI-driven features within the server. **Important Considerations:** * **MCP Protocol Complexity:** The Minecraft protocol is complex. This example simplifies it drastically. Building a real server requires deep understanding of the protocol and handling many packet types. * **Spring AI's Role:** Spring AI is used here to *potentially* add AI-driven features. The core server functionality is separate. The example shows how you *could* integrate AI for things like responding to player commands or generating content. * **Incomplete Example:** This is a *very* basic starting point. It lacks error handling, proper packet parsing, world management, player management, and many other essential features. * **Libraries:** You'll need to add dependencies to your `pom.xml` or `build.gradle` for Spring Boot, Spring AI, and potentially a networking library like Netty (although this example uses basic Java sockets for simplicity). **Conceptual Code Example (Java with Spring Boot and Spring AI):** ```java // pom.xml (or build.gradle) - Add these dependencies // <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 another AI provider // <version>0.8.0</version> // Check for the latest version // </dependency> // <dependency> // <groupId>org.springframework.boot</groupId> // <artifactId>spring-boot-starter-test</artifactId> // <scope>test</scope> // </dependency> import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.ai.client.AiClient; import org.springframework.ai.prompt.PromptTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import javax.annotation.PostConstruct; import java.io.DataInputStream; import java.io.DataOutputStream; 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 executorService = Executors.newFixedThreadPool(10); // Thread pool for handling clients @Autowired private AiClient aiClient; // Inject Spring AI client @PostConstruct public void startServer() { try (ServerSocket serverSocket = new ServerSocket(PORT)) { System.out.println("Minecraft server started on port " + PORT); while (true) { Socket clientSocket = serverSocket.accept(); System.out.println("New client connected: " + clientSocket.getInetAddress()); executorService.submit(new ClientHandler(clientSocket, aiClient)); // Pass AI client to handler } } catch (IOException e) { System.err.println("Server exception: " + e.getMessage()); e.printStackTrace(); } } static class ClientHandler implements Runnable { private final Socket clientSocket; private final AiClient aiClient; public ClientHandler(Socket socket, AiClient aiClient) { this.clientSocket = socket; this.aiClient = aiClient; } @Override public void run() { try (DataInputStream in = new DataInputStream(clientSocket.getInputStream()); DataOutputStream out = new DataOutputStream(clientSocket.getOutputStream())) { // **VERY BASIC** handshake (simplified) int packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); if (packetId == 0x00) { // Example: Handshake packet ID // Read handshake data (protocol version, server address, port, next state) int protocolVersion = readVarInt(in); String serverAddress = readString(in); int serverPort = in.readUnsignedShort(); int nextState = in.readUnsignedByte(); System.out.println("Handshake: Protocol " + protocolVersion + ", Address " + serverAddress + ", Port " + serverPort + ", Next State " + nextState); if (nextState == 1) { // Status request // Respond with server status (simplified) String statusJson = "{\"version\": {\"name\": \"My Server\", \"protocol\": " + protocolVersion + "}, \"players\": {\"max\": 10, \"online\": 0}, \"description\": {\"text\": \"A simple server\"}}"; sendString(out, statusJson); // Read ping packet and respond (simplified) packetId = in.readUnsignedByte(); if (packetId == 0x01) { long pingPayload = in.readLong(); sendLong(out, pingPayload); } } else if (nextState == 2) { // Login request // Handle login (simplified) String playerName = readString(in); System.out.println("Player " + playerName + " is trying to log in."); // **AI Integration Example:** Use AI to generate a welcome message PromptTemplate promptTemplate = new PromptTemplate("Generate a welcome message for player {playerName} joining the server."); promptTemplate.add("playerName", playerName); String aiWelcomeMessage = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Welcome Message: " + aiWelcomeMessage); // Send login success (simplified) sendLoginSuccess(out, playerName); // Send a chat message (simplified) - including the AI message sendChatMessage(out, "Server: Welcome, " + playerName + "! " + aiWelcomeMessage); // Start game logic (simplified) - send join game packet, etc. sendJoinGame(out); } } // Keep the connection alive and handle further packets (simplified) while (clientSocket.isConnected()) { try { packetId = in.readUnsignedByte(); System.out.println("Received packet ID: " + packetId); // Example: Handle chat message (0x03) if (packetId == 0x03) { String chatMessage = readString(in); System.out.println("Received chat message: " + chatMessage); // **AI Integration Example:** Use AI to respond to the chat message PromptTemplate promptTemplate = new PromptTemplate("Respond to the following chat message: {chatMessage}"); promptTemplate.add("chatMessage", chatMessage); String aiResponse = aiClient.generate(promptTemplate.create()).getGeneration().getText(); System.out.println("AI Response: " + aiResponse); sendChatMessage(out, "Server (AI): " + aiResponse); } // Add more packet handling logic here... } catch (IOException e) { // Client disconnected System.out.println("Client disconnected: " + clientSocket.getInetAddress()); break; } } } catch (IOException e) { System.err.println("Client handler exception: " + e.getMessage()); e.printStackTrace(); } finally { try { clientSocket.close(); } catch (IOException e) { System.err.println("Error closing socket: " + e.getMessage()); } } } // Helper methods for reading and writing data (VarInt, String, etc.) - See below private int readVarInt(DataInputStream in) throws IOException { int numRead = 0; int result = 0; byte read; do { read = in.readByte(); int value = (read & 0x7f); result |= (value << (7 * numRead)); numRead++; if (numRead > 5) { throw new RuntimeException("VarInt is too big"); } } while ((read & 0x80) != 0); return result; } private String readString(DataInputStream in) throws IOException { int length = readVarInt(in); byte[] bytes = new byte[length]; in.readFully(bytes); return new String(bytes); } private void sendString(DataOutputStream out, String s) throws IOException { byte[] bytes = s.getBytes("UTF-8"); writeVarInt(out, bytes.length); out.write(bytes); } private void sendLong(DataOutputStream out, long l) throws IOException { out.writeByte(0x01); // Packet ID out.writeLong(l); out.flush(); } private void writeVarInt(DataOutputStream out, int value) throws IOException { while (true) { if ((value & ~0x7F) == 0) { out.writeByte(value); return; } else { out.writeByte((value & 0x7F) | 0x80); value >>>= 7; } } } private void sendChatMessage(DataOutputStream out, String message) throws IOException { out.writeByte(0x0F); // Chat Message packet ID sendString(out, "{\"text\":\"" + message + "\"}"); // JSON formatted chat message out.writeByte(0x00); // Position (0: chat box, 1: system message, 2: game info) out.writeByte(0x00); // Sender UUID (not used in this example) out.flush(); } private void sendLoginSuccess(DataOutputStream out, String playerName) throws IOException { out.writeByte(0x02); // Login Success packet ID sendString(out, "00000000-0000-0000-0000-000000000000"); // UUID (dummy) sendString(out, playerName); writeVarInt(out, 0); // Number of properties (none in this example) out.flush(); } private void sendJoinGame(DataOutputStream out) throws IOException { out.writeByte(0x26); // Join Game packet ID out.writeInt(0); // Entity ID out.writeByte(0); // Gamemode (Survival) out.writeByte(0); // Dimension (Overworld) out.writeByte(1); // Hashed seed out.writeByte(0); // Max Players sendString(out, "minecraft:overworld"); // Level Type writeVarInt(out, 32); // View Distance writeVarInt(out, 32); // Simulation Distance out.writeByte(0); // Reduced Debug Info out.writeByte(0); // Enable respawn screen out.writeByte(0); // Is hardcore out.writeByte(0); // Is flat out.flush(); } } } ``` **Explanation and Key Points:** 1. **Dependencies:** Make sure you have the necessary Spring Boot, Spring AI, and potentially other dependencies (like Netty for more robust networking) in your `pom.xml` or `build.gradle`. The example shows the Spring AI OpenAI starter. You'll need an OpenAI API key configured in your `application.properties` or `application.yml` file. 2. **`MinecraftServerApplication`:** A standard Spring Boot application entry point. 3. **`MinecraftServer`:** * `@Component`: Makes this a Spring-managed bean. * `@Autowired AiClient`: Injects the Spring AI client. This is how you access the AI functionality. * `@PostConstruct`: Ensures that `startServer()` is called after the Spring context is initialized. * `ServerSocket`: Listens for incoming connections on port 25565 (the default Minecraft port). * `ExecutorService`: A thread pool to handle multiple client connections concurrently. * `ClientHandler`: A `Runnable` that handles the communication with a single client. 4. **`ClientHandler`:** * `Socket`: Represents the connection to a Minecraft client. * `DataInputStream` and `DataOutputStream`: Used for reading and writing data to the client socket. Minecraft uses a binary protocol. * **Handshake (Simplified):** The code attempts to handle the initial handshake packet (ID 0x00). This is *highly* simplified. A real server needs to handle the handshake correctly to determine the client's protocol version and intended state (status or login). * **Status Request (Simplified):** If the client requests the server status (next state = 1), the server sends a basic JSON response with server information. * **Login Request (Simplified):** If the client requests to log in (next state = 2), the server reads the player's name. * **AI Integration (Welcome Message):** This is where Spring AI comes in. A `PromptTemplate` is used to create a prompt for the AI: "Generate a welcome message for player {playerName} joining the server." The `aiClient.generate()` method sends the prompt to the AI provider (e.g., OpenAI) and gets a response. The AI-generated message is then included in the chat message sent to the player. * **Chat Message Handling (Simplified):** The code attempts to handle chat messages (packet ID 0x03). * **AI Integration (Chat Response):** Another example of AI integration. The AI is used to respond to the player's chat message. * **Packet Handling:** The `while (clientSocket.isConnected())` loop is where you would add logic to handle other Minecraft packets. You need to read the packet ID and then parse the packet data according to the Minecraft protocol specification. * **Helper Methods:** The `readVarInt`, `readString`, `sendString`, `sendLong`, `writeVarInt`, `sendChatMessage`, `sendLoginSuccess`, and `sendJoinGame` methods are helper functions for reading and writing data in the format expected by the Minecraft protocol. `VarInt` is a variable-length integer encoding. 5. **AI Configuration:** You'll need to configure your Spring AI client in your `application.properties` or `application.yml` file. For example, if you're using OpenAI: ```properties spring.ai.openai.api-key=YOUR_OPENAI_API_KEY ``` **To Run This Example (Conceptual):** 1. **Create a Spring Boot project:** Use Spring Initializr (start.spring.io) to create a new Spring Boot project with the Web, Spring AI (OpenAI or another provider), and potentially other dependencies. 2. **Add the code:** Copy the code above into your project. 3. **Configure Spring AI:** Add your OpenAI API key (or the API key for your chosen AI provider) to your `application.properties` or `application.yml` file. 4. **Run the application:** Run the Spring Boot application. 5. **Connect with a Minecraft client:** Try connecting to `localhost:25565` with a Minecraft client. **Important:** This example is *very* basic and likely won't work perfectly with a standard Minecraft client without significant modifications. You'll probably need to use a custom client or a modified version of the game to test it effectively. **Next Steps (To Make This More Functional):** * **Implement the Full Minecraft Protocol:** This is the biggest task. You need to understand and implement the correct packet handling for all the packets you want to support. Refer to the Minecraft protocol documentation (e.g., on the Minecraft Wiki). * **World Management:** Create a system for loading, saving, and managing the game world. * **Player Management:** Track player data (inventory, position, health, etc.). * **Game Logic:** Implement the core game mechanics (e.g., block breaking, placing, entity movement, combat). * **Error Handling:** Add robust error handling to catch exceptions and prevent the server from crashing. * **Networking:** Consider using a more robust networking library like Netty for better performance and scalability. * **Security:** Implement security measures to prevent cheating and unauthorized access. * **Configuration:** Use Spring Boot's configuration features to make the server configurable (e.g., port number, world name, AI settings). **Important Notes on AI Integration:** * **Cost:** Using AI services like OpenAI can incur costs based on usage. Be mindful of your API usage and set limits if necessary. * **Latency:** AI requests can introduce latency. Consider using asynchronous processing or caching to minimize the impact on the game's responsiveness. * **Creativity vs. Control:** AI can generate creative content, but you may need to fine-tune the prompts and responses to ensure they fit the game's context and rules. * **Ethical Considerations:** Be aware of the ethical implications of using AI in your game, such as potential biases in the AI's responses. This example provides a starting point for building a Minecraft server with Spring AI. It's a complex project, but with careful planning and implementation, you can create a unique and engaging gaming experience. Remember to consult the Minecraft protocol documentation and the Spring AI documentation for more detailed information.

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