Discover Awesome MCP Servers

MCP Simple Server

Un servidor sencillo que implementa el Protocolo de Contexto del Modelo para la búsqueda de documentos.

LumenX-MCP Legal Spend Intelligence Server

MCP server that enables intelligent analysis of legal spend data across multiple sources (LegalTracker, databases, CSV/Excel files), providing features like spend summaries, vendor performance analysis, and budget comparisons.

mcp-mysql-lens

MCP server to connect MySQL DB for read-only queries. It offers accurate query execution.

WordPress Code Review MCP Server

A lightweight, configurable server that fetches coding guidelines, security rules, and validation patterns from external sources to help development teams maintain code quality standards in WordPress projects.

YouTube to LinkedIn MCP Server

Espejo de

Next.js MCP Server

A template MCP server built with Next.js using the Vercel MCP Adapter. Provides a framework for deploying MCP servers with custom tools, prompts, and resources on Vercel with SSE transport support.

MCP Server Boilerplate

A starter template for building custom MCP servers that can integrate with Claude Desktop, Cursor, and other AI assistants. Provides example tools, TypeScript support, and automated publishing workflow to help developers create their own tools and resource providers.

Oracle Sales MCP Server by CData

This read-only MCP Server allows you to connect to Oracle Sales data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Spiral MCP Server

Una implementación de servidor del Protocolo de Contexto de Modelo que proporciona una interfaz estandarizada para interactuar con los modelos de lenguaje de Spiral, ofreciendo herramientas para generar texto a partir de indicaciones (prompts), archivos o URLs web.

MCP Client-Server Sandbox for LLM Augmentation

Banco de pruebas completo para aumentar la inferencia de LLM (local o en la nube) con MCP Cliente-Servidor. Entorno de pruebas de baja fricción para la validación del servidor MCP y la evaluación agentica.

Kodit

A Code Indexing MCP Server that connects AI coding assistants to external codebases, providing accurate and up-to-date code snippets to reduce mistakes and hallucinations.

Quack MCP Server

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

MCP Hub Database Server

Enables querying and searching the MCP Hub database to discover MCP servers, view server details, find top servers by popularity or recency, and identify top contributors.

Vault MCP Server

Enables interaction with HashiCorp Vault to read, write, list, and delete secrets through a containerized MCP server with secure token-based authentication.

web-monitor-mcp-safepoint

The mcp server for safepoint web monitor

OpenTargets MCP Server

Unofficial Model Context Protocol server for accessing Open Targets platform data for gene-drug-disease associations research.

Your Money Left The Chat

A Rust + MCP powered financial tracker that knows exactly where your money ghosted you.

Awesome MCP Servers

Una colección exhaustiva de servidores de Protocolo de Contexto de Modelo (MCP).

Tiger MCP

Enables trading and market analysis through Tiger Brokers API integration. Provides real-time market data, portfolio management, order execution, and technical analysis tools with a comprehensive web dashboard for monitoring.

Minecraft MCP Server

A client library that connects AI agents to Minecraft servers, providing full game control with 30 verified skills for common tasks including movement, combat, crafting, and building.

UK Bus Departures MCP Server

Enables users to get real-time UK bus departure information and validate bus stop ATCO codes by scraping bustimes.org. Provides structured data including service numbers, destinations, scheduled and expected departure times for any UK bus stop.

MCP Perplexity Server

Provides AI-powered search, research, and reasoning capabilities through integration with Perplexity.ai, offering three specialized tools: general conversational AI, deep research with citations, and advanced reasoning.

Mcp Akshare

AKShare es una biblioteca de interfaz de datos financieros basada en Python, cuyo objetivo es implementar un conjunto de herramientas para la recopilación, limpieza y almacenamiento de datos fundamentales, datos de mercado en tiempo real e históricos, y datos derivados de productos financieros como acciones, futuros, opciones, fondos, divisas, bonos, índices y criptomonedas. Se utiliza principalmente con fines de investigación académica.

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.

A MCP server for Godot RAG

Este servidor MCP se utiliza para proporcionar documentación de Godot al modelo RAG de Godot.

MCP Demo Server

A minimal fastmcp demonstration server that provides a simple addition tool through the MCP protocol, supporting deployment via Docker with multiple transport modes.

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!