Discover Awesome MCP Servers

Minimal MCP Server

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

Local iMessage RAG MCP Server

iMessage RAG MCP Server from Anthropic MCP Hackathon (NYC)

Trino MCP Server

Espejo de

Mcp Namecheap Registrar

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

HQ Pool Services Website

Test w/ Figma MCP server to generate a pool services page

🌟 Unsplash MCP Server Repository

🔎 A MCP server for Unsplash image search.

Mcp Servers Collection

Colección de servidores e integraciones MCP verificados

@enemyrr/mcp-mysql-server

Espejo de

MCP Actions Adapter

A simple adapter to convert a MCP server to a GPT actions compatible API

worker17

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

Alpaca MCP Server

Espejo de

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.

Wisdom MCP Gateway

A stdio gateway for the Enterpret's Wisdom MCP SSE Server

MCP (Model Context Protocol)

Un Servidor de Contexto de Modelo Simple para IA

T2_C2

Server code for MCP

Atlassian Jira MCP Server

Node.js/TypeScript MCP server for Atlassian Jira. Equips AI systems (LLMs) with tools to list/get projects, search/get issues (using JQL/ID), and view dev info (commits, PRs). Connects AI capabilities directly into Jira project management and issue tracking workflows.

Chrome MCP Server

Servidor MCP para integração entre extensão Chrome e Claude AI

MSSQL MCP Server

Espejo de

ディーゼロ開発環境用 MCPサーバー

D-Zero frontend coding MCP server

Servidor MCP do Supabase

Servidor MCP do Supabase com funcionalidades de consulta e inserção de dados

🌱 mcp-origin

MCP server that manages MCP servers

Eka MCP Server

Servidor Eka MCP

Polkassembly MCP Server

MCP Server for Polkassembly API

RapidAPI MCP Server

Here's a translation of "MCP Server implementation for RapidAPI Global Patent API integration with SQLite storage" into Spanish, with a few options depending on the nuance you want to convey: **Option 1 (Most Direct):** * **Implementación de un servidor MCP para la integración de la API Global de Patentes de RapidAPI con almacenamiento SQLite.** **Option 2 (More Emphasis on "Using"):** * **Implementación de un servidor MCP utilizando la API Global de Patentes de RapidAPI e integrando almacenamiento SQLite.** **Option 3 (Slightly More Formal):** * **Implementación de servidor MCP para la integración con la API Global de Patentes de RapidAPI, utilizando almacenamiento SQLite.** **Explanation of Choices:** * **MCP Server:** "Servidor MCP" is generally fine. MCP (Master Control Program) is often understood in technical contexts. * **RapidAPI Global Patent API:** "API Global de Patentes de RapidAPI" is a direct and clear translation. * **Integration:** "Integración" is the standard translation for integration. * **SQLite Storage:** "Almacenamiento SQLite" is the standard translation. * **"For" vs. "Using":** The choice between "para" (for) and "utilizando" (using) depends on whether you want to emphasize the *purpose* of the implementation (Option 1) or the *method* of the implementation (Option 2). Option 3 is a compromise. I would recommend **Option 1** unless you specifically want to highlight the use of the API and SQLite in the implementation.