Discover Awesome MCP Servers

PayHub MCP Server

Enables querying real disclosed salary data across 20 regions, with tools to search jobs, retrieve salary statistics, and find similar roles.

Wedding Invitation Builder MCP

Enables creating and customizing mobile wedding invitations through natural language, with support for multiple designs, RSVP, maps, gallery, and share tokens.

livespace-crm-mcp

Unofficial MCP server for Livespace CRM, exposing 11 intent-shaped tools for safe, bounded read and write operations on records, deals, activities, and notifications via Streamable HTTP.

SwiftOpenAI MCP Server

A universal server that enables MCP-compatible clients (like Claude Desktop, Cursor, VS Code) to access OpenAI's APIs for chat completions, image generation, embeddings, and model listing through a standardized interface.

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.

discord-mcp-server

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

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.

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.

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.

A MCP server for Godot RAG

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

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.

reddit-trends-mcp

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

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.

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.

ferric-fred-mcp

A strongly-typed, single-binary MCP server for FRED (Federal Reserve Economic Data), written in Rust.

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.

Mandados de Prisão (CNJ)

Enables checking for open arrest warrants in the Brazilian CNJ national database using a person's CPF and name, via a hosted read-only MCP server.

Knowi-mcp

Knowi’s MCP server gives AI tools full access to the entire analytics workflow. Knowi's 20+ specialized data agents automatically chain together to connect you datasources, write queries, build dashboards, and deliver reports.

MCP Memory

An MCP server that enables clients like Cursor, Claude, and Windsurf to remember user information and preferences across conversations using vector search technology.

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.

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.

claude-remind-mcp

Searches your local Claude Code conversation history to recall and resume past solutions.

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.

Dovetail MCP Server

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

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.

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.

Hermai MCP

Enables agent runtimes to look up, classify, and fetch Hermai schemas as MCP tools, including read-only data retrieval via hosted endpoints (with optional API key).

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.