Discover Awesome MCP Servers

Minecraft MCP Server

An early prototype of a Model Context Protocol (MCP) server implementation integrating the Mineflayer API to interact with Minecraft

ConsultingAgents MCP Server

Un servidor MCP que interactúa con las APIs de OpenAI y Anthropic para proporcionar "compañeros de trabajo" de Claude Code que le ayuden con problemas difíciles.

Anki MCP Server

Mirror of

Salesforce MCP Server

Mirror of

gorse

Data On Tap Inc. es un MVNO completo que opera en la red 302 100 en Canadá. Este es el repositorio de código de DOT. Incluye seguridad y autenticación avanzadas, varias herramientas de conectividad, inteligencia, incluyendo reservas de red inteligentes, eSIM/iSIM, conectividad inalámbrica bootstrap, satélite D2C, marcos de trabajo y conceptos para construir sobre ellos. OpenAPI 3.1. Servidor MCP.

Confluence Wiki MCP Server Extension

Mirror of

Twilio MCP Server

Mirror of

MCPHub 🚀

MCPHub - A cross-platform GUI application to discover, install, and manage Model Context Protocol (MCP) servers. Think of it as apt/pip but for MCP servers.

Quarkus Model Context Protocol (MCP) Server

This extension enables developers to implement the MCP server features easily.

🌟 Unsplash MCP Server Repository

🔎 A MCP server for Unsplash image search.

Mcp Namecheap Registrar

Connects to namecheap api for checking availability and pricing of domains and registering them.

MCP Bundler Service

Un microservicio para empaquetar servidores MCP desde repositorios de GitHub y prepararlos para su despliegue.

mcp-server

learn to make some mcp servers

Minimal MCP Server

A minimal implementation of a Model Context Protocol (MCP) server

worker17

An MCP server to monitor workers productivity and fire them as needed.

Mcp Servers Collection

Colección de servidores e integraciones MCP verificados

mcp-server-yahoo-finance MCP server

Espejo de

MQTTX SSE Server

Una implementación del Protocolo Modelo-Contexto (MCP) que permite operaciones MQTT a través del transporte de Eventos Enviados por el Servidor (SSE).

MCP Test Client

MCP Test Client is a TypeScript testing utility for Model Context Protocol (MCP) servers.

ActionKit MCP Starter

Okay, here's a basic starter code structure and explanation for setting up an MCP (Minecraft Protocol) server powered by ActionKit (assuming you're referring to ActionKit, the open-source advocacy platform, and want to integrate it with a Minecraft server for some kind of interactive campaign or event). This is a conceptual outline, as the specific implementation will depend heavily on what you want to *do* with the integration. **Important Considerations:** * **ActionKit API:** You'll need to understand the ActionKit API to interact with it. This includes authentication, retrieving user data, and potentially creating actions (e.g., signing a petition, donating) based on in-game events. Refer to the ActionKit documentation for details. * **Minecraft Server API:** You'll need to use a Minecraft server API (e.g., Bukkit/Spigot, Fabric, or a lower-level library like `minecraft-protocol`) to interact with the Minecraft server. The choice depends on your needs and the level of control you require. Bukkit/Spigot are common for plugins, while Fabric is a modern alternative. `minecraft-protocol` gives you the most control but requires more coding. * **Language:** I'll assume you're using Python for the ActionKit interaction and Java/Kotlin for the Minecraft server plugin (if using Bukkit/Spigot or Fabric). You could use other languages, but these are common choices. * **Security:** Be extremely careful about security. Never expose your ActionKit API keys directly in your Minecraft plugin. Use environment variables or a secure configuration file. Validate all data received from the Minecraft server before sending it to ActionKit, and vice versa. * **Scalability:** Consider the scalability of your solution. If you expect a large number of players, you'll need to optimize your code and potentially use a message queue (e.g., RabbitMQ, Kafka) to handle the communication between the Minecraft server and ActionKit. **Conceptual Architecture:** 1. **Minecraft Server Plugin (Java/Kotlin):** * Listens for in-game events (e.g., player join, chat messages, specific actions). * Communicates with a separate Python script (or a web service) to interact with the ActionKit API. This communication can be done via HTTP requests (e.g., using `java.net.http` in Java 11+ or a library like OkHttp) or a message queue. * Receives data from the Python script (e.g., ActionKit user data, instructions) and uses it to modify the game world or player experience. 2. **Python Script (or Web Service):** * Receives requests from the Minecraft server plugin. * Authenticates with the ActionKit API. * Retrieves or creates data in ActionKit based on the requests. * Sends responses back to the Minecraft server plugin. **Starter Code (Conceptual):** **1. Minecraft Server Plugin (Java - Bukkit/Spigot Example):** ```java // ExamplePlugin.java package com.example; import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerJoinEvent; import org.bukkit.entity.Player; import java.io.IOException; import java.net.URI; import java.net.http.HttpClient; import java.net.http.HttpRequest; import java.net.http.HttpResponse; import com.google.gson.Gson; import java.util.HashMap; import java.util.Map; public class ExamplePlugin extends JavaPlugin implements Listener { private final String ACTIONKIT_API_URL = "http://your-python-server:5000/actionkit"; // Replace with your Python server URL @Override public void onEnable() { getLogger().info("ExamplePlugin has been enabled!"); getServer().getPluginManager().registerEvents(this, this); } @Override public void onDisable() { getLogger().info("ExamplePlugin has been disabled!"); } @EventHandler public void onPlayerJoin(PlayerJoinEvent event) { Player player = event.getPlayer(); String playerName = player.getName(); // Asynchronously fetch ActionKit data for the player getServer().getScheduler().runTaskAsynchronously(this, () -> { try { String actionKitData = fetchActionKitData(playerName); // Process the ActionKit data (e.g., display a message, grant permissions) getServer().getScheduler().runTask(this, () -> { // Back to main thread for Bukkit API calls player.sendMessage("ActionKit Data: " + actionKitData); }); } catch (IOException | InterruptedException e) { getLogger().severe("Error fetching ActionKit data: " + e.getMessage()); getServer().getScheduler().runTask(this, () -> { player.sendMessage("Error fetching ActionKit data. See server logs."); }); } }); } private String fetchActionKitData(String playerName) throws IOException, InterruptedException { // Build the request to the Python server HttpClient client = HttpClient.newHttpClient(); Gson gson = new Gson(); Map<String, String> requestBodyMap = new HashMap<>(); requestBodyMap.put("username", playerName); String requestBody = gson.toJson(requestBodyMap); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(ACTIONKIT_API_URL)) .header("Content-Type", "application/json") .POST(HttpRequest.BodyPublishers.ofString(requestBody)) .build(); // Send the request and get the response HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { return response.body(); } else { getLogger().severe("ActionKit API request failed with status code: " + response.statusCode()); return "Error: " + response.statusCode(); } } } ``` **pom.xml (Maven - for building the plugin):** ```xml <project> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>ExamplePlugin</artifactId> <version>1.0-SNAPSHOT</version> <packaging>jar</packaging> <properties> <maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target> </properties> <dependencies> <!-- Spigot API --> <dependency> <groupId>org.spigotmc</groupId> <artifactId>spigot-api</artifactId> <version>1.19.4-R0.1-SNAPSHOT</version> <!-- Replace with your Spigot version --> <scope>provided</scope> </dependency> <!-- Gson for JSON parsing --> <dependency> <groupId>com.google.code.gson</groupId> <artifactId>gson</artifactId> <version>2.8.9</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>3.2.4</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> </execution> </executions> </plugin> </plugins> </build> </project> ``` **2. Python Script (Flask Example):** ```python # app.py from flask import Flask, request, jsonify import requests import os app = Flask(__name__) ACTIONKIT_API_BASE_URL = os.environ.get("ACTIONKIT_API_BASE_URL", "https://your-actionkit-instance.org/api/v1/") # Replace with your ActionKit URL ACTIONKIT_USERNAME = os.environ.get("ACTIONKIT_USERNAME", "your_username") ACTIONKIT_PASSWORD = os.environ.get("ACTIONKIT_PASSWORD", "your_password") def authenticate_actionkit(): """Authenticates with ActionKit and returns the session.""" session = requests.Session() session.auth = (ACTIONKIT_USERNAME, ACTIONKIT_PASSWORD) return session @app.route('/actionkit', methods=['POST']) def get_actionkit_data(): data = request.get_json() username = data.get('username') if not username: return jsonify({'error': 'Username is required'}), 400 try: session = authenticate_actionkit() # Example: Fetch user data from ActionKit (replace with your actual API call) user_url = f"{ACTIONKIT_API_BASE_URL}user/?username={username}" response = session.get(user_url) if response.status_code == 200: user_data = response.json() return jsonify(user_data) elif response.status_code == 404: return jsonify({'message': 'User not found in ActionKit'}), 404 else: print(f"ActionKit API Error: {response.status_code} - {response.text}") # Log the error return jsonify({'error': 'Error fetching data from ActionKit'}), 500 except Exception as e: print(f"Exception: {e}") # Log the exception return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0') # Make sure to set debug=False in production ``` **Explanation:** * **Minecraft Plugin (Java):** * `onPlayerJoin`: This event handler is triggered when a player joins the server. * `fetchActionKitData`: This method makes an HTTP POST request to the Python server, sending the player's username. It uses `java.net.http` (available in Java 11+) for making the HTTP request. It also uses Gson to serialize the request body to JSON. * The response from the Python server is then displayed to the player. * **Important:** The `runTaskAsynchronously` and `runTask` calls are crucial. Network requests should *always* be done asynchronously to avoid blocking the main server thread. Bukkit API calls (like `player.sendMessage`) *must* be done on the main thread. * **Python Script (Flask):** * `/actionkit` endpoint: This endpoint receives the username from the Minecraft plugin. * `authenticate_actionkit`: This function handles authentication with the ActionKit API using your username and password (stored as environment variables for security). * The script then makes a request to the ActionKit API to fetch user data based on the username. **Replace the example API call with the actual ActionKit API call you need.** * The response from ActionKit is then sent back to the Minecraft plugin as JSON. * **pom.xml:** This file defines the dependencies for your Java plugin (Spigot API and Gson). Make sure to update the Spigot API version to match your server. The `maven-shade-plugin` is used to create a single JAR file containing all the dependencies. **To Run This Example:** 1. **Set up ActionKit:** Make sure you have an ActionKit instance running and accessible. 2. **Set Environment Variables:** Set the `ACTIONKIT_API_BASE_URL`, `ACTIONKIT_USERNAME`, and `ACTIONKIT_PASSWORD` environment variables on the machine running the Python script. 3. **Install Python Dependencies:** `pip install flask requests` 4. **Run the Python Script:** `python app.py` 5. **Build the Minecraft Plugin:** Use Maven to build the plugin (e.g., `mvn clean install`). This will create a JAR file in the `target` directory. 6. **Install the Plugin:** Copy the JAR file to the `plugins` directory of your Spigot/Bukkit server. 7. **Start the Minecraft Server:** Start your Minecraft server. 8. **Join the Server:** Join the server with a Minecraft account. You should see a message in chat with the ActionKit data (or an error message if something went wrong). **Next Steps:** * **Implement Actual ActionKit Logic:** Replace the example ActionKit API call in the Python script with the actual API calls you need to retrieve or create data in ActionKit. * **Handle Different Events:** Add event handlers to the Minecraft plugin to listen for other in-game events (e.g., chat messages, player actions). * **Secure Communication:** Use HTTPS for communication between the Minecraft plugin and the Python server. * **Error Handling:** Implement robust error handling in both the Minecraft plugin and the Python script. Log errors to files or a logging service. * **Configuration:** Use a configuration file for the Minecraft plugin to store settings like the ActionKit API URL and other parameters. * **Message Queue (Optional):** If you need to handle a large number of requests, consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the Minecraft plugin and the Python script. This is a basic starting point. You'll need to adapt it to your specific needs and requirements. Remember to prioritize security and scalability as you develop your integration. Good luck! **Spanish Translation of Key Points:** * **API de ActionKit:** Necesitarás entender la API de ActionKit para interactuar con ella. Esto incluye la autenticación, la recuperación de datos de usuario y, potencialmente, la creación de acciones (por ejemplo, firmar una petición, donar) basadas en eventos dentro del juego. Consulta la documentación de ActionKit para obtener más detalles. * **API del Servidor de Minecraft:** Necesitarás usar una API del servidor de Minecraft (por ejemplo, Bukkit/Spigot, Fabric o una biblioteca de nivel inferior como `minecraft-protocol`) para interactuar con el servidor de Minecraft. La elección depende de tus necesidades y del nivel de control que requieras. Bukkit/Spigot son comunes para los plugins, mientras que Fabric es una alternativa moderna. `minecraft-protocol` te da el mayor control, pero requiere más código. * **Lenguaje:** Asumiré que estás usando Python para la interacción con ActionKit y Java/Kotlin para el plugin del servidor de Minecraft (si usas Bukkit/Spigot o Fabric). Podrías usar otros lenguajes, pero estas son opciones comunes. * **Seguridad:** Ten mucho cuidado con la seguridad. Nunca expongas tus claves API de ActionKit directamente en tu plugin de Minecraft. Usa variables de entorno o un archivo de configuración seguro. Valida todos los datos recibidos del servidor de Minecraft antes de enviarlos a ActionKit, y viceversa. * **Escalabilidad:** Considera la escalabilidad de tu solución. Si esperas un gran número de jugadores, necesitarás optimizar tu código y, potencialmente, usar una cola de mensajes (por ejemplo, RabbitMQ, Kafka) para manejar la comunicación entre el servidor de Minecraft y ActionKit. The code comments are already in English, as that's the standard for code. If you need specific parts of the code translated, let me know.

Local iMessage RAG MCP Server

iMessage RAG MCP Server from Anthropic MCP Hackathon (NYC)

Trino MCP Server

Espejo de