Discover Awesome MCP Servers

Dockerized Salesforce MCP Server

Dockerized Salesforce MCP Server for REST API integration

s-GitHubTestRepo-Henry

created from MCP server demo

Basilisp nREPL MCP Bridge

simple MCP server for nREPL

Zoom MCP Server

MCP server for Zoom

Exa MCP Server 🔍

Claude có thể thực hiện Tìm kiếm trên Web | Exa với MCP (Giao thức Ngữ cảnh Mô hình).

@modelcontextprotocol/server-terminal

Terminal server implementation for Model Context Protocol

GooseTeam

Look, a flock of geese! An MCP server and protocol for Goose agent collaboration.

Modular Outlook MCP Server

MCP server for Claude to access Outlook data via Microsoft Graph API

mcp-server-datahub

Máy chủ MCP chính thức cho DataHub (

Browser JavaScript Evaluator

This is a reference design for a MCP server that hosts a web page that connects back to the server via sse and allows Claude to execute javascript on the page.

Rails MCP Server

A Ruby gem implementation of a Model Context Protocol (MCP) server for Rails projects. This server allows LLMs (Large Language Models) to interact with Rails projects through the Model Context Protocol.

mcp_server_local_files

Local File System MCP Server

MCP Expert Server

Mirror of

NSAF MCP Server

Gương của

MCP Server Playwright

MCP Server Playwright - Một dịch vụ tự động hóa trình duyệt cho Claude Desktop

iOS Simulator MCP Server

Mirror of

Supergateway

Run MCP stdio servers over SSE and SSE over stdio. AI gateway.

Gmail MCP Server

Mirror of

Fiberflow MCP Gateway

Run Fiberflow MCP SSE Server over stdio.

generator-mcp

Yeoman Generator to quickly create a new MCP Server

FirstCycling MCP Server

Đây là một máy chủ Giao thức Ngữ cảnh Mô hình (MCP) cung cấp dữ liệu về xe đạp chuyên nghiệp từ FirstCycling. Nó cho phép bạn truy xuất thông tin về các tay đua xe đạp chuyên nghiệp, kết quả cuộc đua và hơn thế nữa.

Initial thoughts

Okay, here's a breakdown of how to convert OpenAPI specifications to MCP (presumably, you mean Media Control Platform) server-ready tools, along with considerations and potential approaches. Since "MCP server" is a broad term, I'll make some assumptions and provide general guidance. You'll need to adapt this to your specific MCP server environment. **Understanding the Goal** The core idea is to use your OpenAPI specification (which describes your API) to automatically generate or configure tools that your MCP server can use to interact with that API. This could involve: * **Generating Client Libraries:** Creating code (in a language your MCP server uses, like Python, Java, Go, etc.) that makes it easy to call the API described by the OpenAPI spec. * **Generating Configuration Files:** Creating configuration files (e.g., YAML, JSON) that tell your MCP server how to connect to the API, what endpoints are available, and how to handle authentication. * **Generating API Gateways/Proxies:** Setting up an API gateway (like Kong, Tyk, or even a custom solution) that sits in front of your API and handles things like authentication, rate limiting, and request routing, based on the OpenAPI spec. * **Generating Documentation:** Creating human-readable documentation for the API. **General Workflow** 1. **Obtain the OpenAPI Specification:** Make sure you have a valid OpenAPI specification file (usually in YAML or JSON format). This is the foundation of the entire process. 2. **Choose the Right Tools:** Select tools that can consume OpenAPI specifications and generate the desired output (client libraries, configuration files, etc.). I'll list some popular options below. 3. **Configure the Tools:** Configure the chosen tools to generate the output in the format that your MCP server expects. This might involve specifying the target language, the output directory, and any custom templates. 4. **Integrate with Your MCP Server:** Integrate the generated output (client libraries, configuration files, etc.) into your MCP server's codebase or configuration. 5. **Test Thoroughly:** Test the integration to ensure that your MCP server can successfully interact with the API using the generated tools. **Tools and Techniques** Here are some popular tools and techniques for converting OpenAPI specifications: * **OpenAPI Generator (Recommended):** * **Description:** A powerful and versatile tool that can generate client libraries, server stubs, and documentation in a wide variety of languages and frameworks. * **Languages Supported:** Java, Python, Go, JavaScript, TypeScript, C#, PHP, Ruby, and many more. * **How to Use:** ```bash # Example: Generate a Python client library openapi-generator generate -i your_openapi_spec.yaml -g python -o output_directory ``` * **Pros:** Highly configurable, supports many languages, actively maintained. * **Cons:** Can be complex to configure for advanced use cases. * **Swagger Codegen (Older, but still usable):** * **Description:** The predecessor to OpenAPI Generator. Still works, but OpenAPI Generator is generally preferred. * **How to Use:** Similar to OpenAPI Generator. * **Swagger UI:** * **Description:** A tool for rendering interactive API documentation from an OpenAPI specification. Useful for exploring the API and testing endpoints. * **How to Use:** Serve the Swagger UI files along with your OpenAPI specification. * **Stoplight Studio:** * **Description:** A visual editor for creating and editing OpenAPI specifications. Also includes tools for generating documentation and mocking APIs. * **Pros:** User-friendly interface, good for collaborative development. * **Cons:** May not be as flexible as command-line tools for automated generation. * **Postman:** * **Description:** A popular API client that can import OpenAPI specifications and generate collections of API requests. Useful for testing and debugging. * **How to Use:** Import your OpenAPI specification into Postman and generate a collection. * **Custom Scripting:** * **Description:** If the existing tools don't meet your specific needs, you can write your own scripts (e.g., in Python, Node.js) to parse the OpenAPI specification and generate the desired output. * **Pros:** Maximum flexibility. * **Cons:** Requires more development effort. **Example Scenario (Python MCP Server)** Let's say your MCP server is written in Python, and you want to generate a Python client library from your OpenAPI specification. 1. **Install OpenAPI Generator:** ```bash # You'll need Java installed brew install openapi-generator # (on macOS) # or apt-get install openapi-generator # (on Debian/Ubuntu) ``` 2. **Generate the Python Client:** ```bash openapi-generator generate -i your_openapi_spec.yaml -g python -o python_client ``` 3. **Integrate into Your MCP Server:** * The `python_client` directory will contain the generated Python client library. * Copy this directory into your MCP server's project. * Install any dependencies listed in the `requirements.txt` file (if there is one): ```bash pip install -r python_client/requirements.txt ``` * Import the generated client classes into your MCP server's code and use them to call the API. **Example: Generating Configuration for an API Gateway (Kong)** If you're using Kong as an API gateway, you can use the OpenAPI specification to configure Kong routes, services, and plugins. 1. **Use `kong-declarative-config` (or similar):** Kong supports declarative configuration, where you define the desired state of Kong in a YAML or JSON file. You can use a tool or script to generate this configuration file from your OpenAPI specification. 2. **Example (Conceptual):** ```python # Python script (very simplified example) import yaml import json def generate_kong_config(openapi_spec_file): with open(openapi_spec_file, 'r') as f: openapi_data = yaml.safe_load(f) # or json.load(f) kong_config = { "services": [], "routes": [] } for path, path_data in openapi_data['paths'].items(): for method, operation in path_data.items(): service_name = operation.get('x-kong-service', 'default-service') # Custom extension for service name route_name = operation.get('operationId', f"{method}-{path}") # Add service if it doesn't exist if not any(s['name'] == service_name for s in kong_config['services']): kong_config['services'].append({ "name": service_name, "url": openapi_data['servers'][0]['url'] # Or configure differently }) kong_config['routes'].append({ "name": route_name, "service": {"name": service_name}, "paths": [path], "methods": [method.upper()] }) return kong_config if __name__ == "__main__": kong_config = generate_kong_config("your_openapi_spec.yaml") with open("kong.yaml", "w") as outfile: yaml.dump(kong_config, outfile, indent=2) print("Kong configuration generated in kong.yaml") ``` 3. **Apply the Configuration to Kong:** Use Kong's Admin API or `kong-declarative-config` to apply the generated configuration to your Kong instance. **Important Considerations** * **Custom Extensions:** You can use custom extensions in your OpenAPI specification (using the `x-` prefix) to provide additional information that is specific to your MCP server or API gateway. For example, you might use `x-kong-plugin` to specify which Kong plugins should be applied to a particular route. * **Authentication:** Make sure to handle authentication correctly. Your OpenAPI specification should describe the authentication methods used by your API (e.g., API keys, OAuth 2.0). The generated tools should be configured to handle authentication appropriately. * **Error Handling:** Consider how errors will be handled. The generated client libraries should provide mechanisms for handling API errors. * **Versioning:** If your API has multiple versions, you'll need to manage the OpenAPI specifications for each version and generate tools accordingly. * **Testing:** Thoroughly test the generated tools to ensure that they work correctly and that your MCP server can successfully interact with the API. * **Idempotency:** If your API requires idempotent requests, ensure that the generated client libraries or your MCP server code handles idempotency correctly. **In summary, the best approach depends on your specific MCP server environment, the languages you're using, and the level of automation you need. OpenAPI Generator is a good starting point for generating client libraries. For API gateways, you may need to write custom scripts to generate configuration files based on your OpenAPI specification.** Remember to replace placeholders like `your_openapi_spec.yaml`, `output_directory`, and `python_client` with your actual file names and directory paths. Good luck!

Financial Analysis MCP Server

Gương của

Ghost MCP Server

Mirror of

Weather MCP Server

Okay, here's a sample implementation concept for an MCP (Minecraft Protocol) server that fetches weather forecasts. This is a high-level outline and would require significant coding to implement fully. It focuses on the *idea* of how you might integrate weather data into a Minecraft server using a custom plugin and protocol extension. **Conceptual Overview** 1. **Minecraft Server Plugin (e.g., Spigot, Paper):** This is the core of the integration. It handles: * Listening for custom MCP packets. * Interacting with a weather API. * Sending weather data back to the client. * Potentially modifying the in-game weather based on the forecast. 2. **Weather API:** A service that provides weather data. Examples include: * OpenWeatherMap (requires API key) * WeatherAPI.com (requires API key) * AccuWeather (requires API key) * (Many others) 3. **Custom MCP Packets:** These are the messages exchanged between the client and server. You'll need to define: * **Request Packet (Client -> Server):** Asks for a weather forecast for a specific location (e.g., coordinates, city name). * **Response Packet (Server -> Client):** Contains the weather forecast data (temperature, conditions, wind speed, etc.). 4. **Client-Side Mod (Minecraft Mod):** This mod: * Sends the weather request packet to the server. * Receives the weather response packet. * Displays the weather information to the player (e.g., in a GUI, chat message, or HUD element). **Simplified Code Examples (Conceptual - Requires Adaptation)** **A. Minecraft Server Plugin (Java - Spigot/Paper)** ```java import org.bukkit.plugin.java.JavaPlugin; import org.bukkit.event.Listener; import org.bukkit.event.EventHandler; 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 com.google.gson.JsonObject; public class WeatherPlugin extends JavaPlugin implements Listener { private final String WEATHER_API_KEY = "YOUR_API_KEY"; // Replace with your actual API key private final String WEATHER_API_URL = "https://api.openweathermap.org/data/2.5/weather?lat=%s&lon=%s&appid=" + WEATHER_API_KEY + "&units=metric"; // Example OpenWeatherMap URL @Override public void onEnable() { getLogger().info("WeatherPlugin has been enabled!"); getServer().getPluginManager().registerEvents(this, this); // Register custom packet listener (implementation not shown here - complex) } @Override public void onDisable() { getLogger().info("WeatherPlugin has been disabled!"); } @EventHandler public void onPlayerJoin(PlayerJoinEvent event) { Player player = event.getPlayer(); // Example: Get weather on player join (replace with packet handling) getServer().getScheduler().runTaskAsynchronously(this, () -> { try { String weatherData = getWeatherData(player.getLocation().getLatitude(), player.getLocation().getLongitude()); if (weatherData != null) { // Parse weather data (using Gson or similar) Gson gson = new Gson(); JsonObject jsonObject = gson.fromJson(weatherData, JsonObject.class); String description = jsonObject.getAsJsonArray("weather").get(0).getAsJsonObject().get("description").getAsString(); double temperature = jsonObject.getAsJsonObject("main").get("temp").getAsDouble(); player.sendMessage("Weather: " + description + ", Temperature: " + temperature + "°C"); // Send custom packet to client (implementation not shown here) // sendWeatherPacket(player, description, temperature); } else { player.sendMessage("Failed to retrieve weather data."); } } catch (IOException | InterruptedException e) { getLogger().severe("Error fetching weather data: " + e.getMessage()); player.sendMessage("Error retrieving weather data."); } }); } private String getWeatherData(double latitude, double longitude) throws IOException, InterruptedException { String url = String.format(WEATHER_API_URL, latitude, longitude); HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .build(); HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); if (response.statusCode() == 200) { return response.body(); } else { getLogger().warning("Weather API request failed with status code: " + response.statusCode()); return null; } } // (Implementation for sending custom MCP packets is not included here - very complex) // private void sendWeatherPacket(Player player, String description, double temperature) { ... } } ``` **B. Client-Side Mod (Java - Forge/Fabric)** ```java // Example using Forge (adapt for Fabric if needed) import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.event.FMLInitializationEvent; import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.common.network.FMLNetworkEvent; import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.common.network.NetworkRegistry; import net.minecraftforge.fml.common.network.simpleimpl.IMessage; import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler; import net.minecraftforge.fml.common.network.simpleimpl.MessageContext; import net.minecraft.client.Minecraft; import net.minecraft.util.text.TextComponentString; import io.netty.buffer.ByteBuf; import net.minecraftforge.fml.common.event.FMLPreInitializationEvent; @Mod(modid = "weathermod", name = "Weather Mod", version = "1.0") public class WeatherMod { @Mod.Instance("weathermod") public static WeatherMod instance; public static SimpleNetworkWrapper network; @Mod.EventHandler public void preInit(FMLPreInitializationEvent event) { network = NetworkRegistry.INSTANCE.newSimpleChannel("weathermod"); network.registerMessage(WeatherMessageHandler.class, WeatherMessage.class, 0, Side.CLIENT); } @Mod.EventHandler public void init(FMLInitializationEvent event) { // Register event handler for network events (e.g., connection) NetworkRegistry.INSTANCE.registerGuiHandler("weathermod", new GuiProxy()); } // Example: Send a weather request when the client connects (replace with a more appropriate trigger) @SubscribeEvent public void onClientConnectedToServer(FMLNetworkEvent.ClientConnectedToServerEvent event) { // Send a request packet to the server (implementation not shown here) // network.sendToServer(new WeatherRequestMessage()); // Example } // Inner class for the Weather Message public static class WeatherMessage implements IMessage { public String description; public double temperature; public WeatherMessage() {} // Required empty constructor public WeatherMessage(String description, double temperature) { this.description = description; this.temperature = temperature; } @Override public void fromBytes(ByteBuf buf) { description = io.netty.util.CharsetUtil.UTF_8.decode(buf.readBytes(buf.readInt())).toString(); temperature = buf.readDouble(); } @Override public void toBytes(ByteBuf buf) { byte[] stringBytes = description.getBytes(io.netty.util.CharsetUtil.UTF_8); buf.writeInt(stringBytes.length); buf.writeBytes(stringBytes); buf.writeDouble(temperature); } } // Inner class for the Weather Message Handler public static class WeatherMessageHandler implements IMessageHandler<WeatherMessage, IMessage> { @Override public IMessage onMessage(WeatherMessage message, MessageContext ctx) { Minecraft.getMinecraft().addScheduledTask(() -> { Minecraft.getMinecraft().player.sendMessage(new TextComponentString("Weather: " + message.description + ", Temperature: " + message.temperature + "°C")); }); return null; } } // Example GuiProxy (needed for Forge networking) public static class GuiProxy implements net.minecraftforge.fml.common.network.IGuiHandler { @Override public Object getServerGuiElement(int ID, net.minecraft.entity.player.EntityPlayer player, net.minecraft.world.World world, int x, int y, int z) { return null; } @Override public Object getClientGuiElement(int ID, net.minecraft.entity.player.EntityPlayer player, net.minecraft.world.World world, int x, int y, int z) { return null; } } } ``` **C. MCP Packet Definitions (Conceptual)** * **WeatherRequestPacket:** * Data: Latitude, Longitude (or City Name String) * **WeatherResponsePacket:** * Data: Description (String), Temperature (Double), Wind Speed (Double), etc. (Whatever data you want to display) **Important Considerations and Challenges:** * **MCP Protocol Complexity:** Directly manipulating the Minecraft protocol is *very* complex. You'll need to understand packet structures, IDs, and how to inject custom packets. Libraries like `PacketLib` (for Spigot) can help, but it's still advanced. The example above uses Forge's built-in networking, which is much easier. * **API Keys:** Weather APIs typically require API keys. Handle these securely (don't hardcode them in your mod/plugin). Consider using a configuration file. * **Error Handling:** Network requests can fail. Handle errors gracefully and provide informative messages to the player. * **Rate Limiting:** Weather APIs often have rate limits (how many requests you can make per time period). Avoid exceeding these limits, or your API key may be blocked. Implement caching to reduce the number of API calls. * **Data Parsing:** Weather APIs return data in JSON or XML format. Use a library like Gson (Java) to parse the data. * **Threading:** Network requests should be done asynchronously (in a separate thread) to avoid blocking the main Minecraft server thread. The example uses `getServer().getScheduler().runTaskAsynchronously()`. * **Security:** Be careful about what data you send and receive. Validate data to prevent exploits. * **Cross-Version Compatibility:** Minecraft's protocol changes between versions. Your mod/plugin may need to be updated for each new version. Forge and Fabric provide abstraction layers to help with this, but it's still a concern. * **Location:** How do you determine the player's location for the weather forecast? Using coordinates is accurate, but city names might be more user-friendly. Consider allowing the player to configure their location. * **Display:** How will you display the weather information to the player? Chat messages are simple, but a GUI or HUD element might be more immersive. **Steps to Implement (Rough Outline):** 1. **Set up a Development Environment:** Install the Minecraft server (Spigot/Paper) and a modding framework (Forge/Fabric). 2. **Choose a Weather API:** Sign up for an API key. 3. **Create the Server Plugin:** * Implement the plugin's core logic (as shown in the example). * Implement the custom packet handling (the most complex part). * Test the plugin. 4. **Create the Client-Side Mod:** * Implement the mod's core logic. * Implement the packet sending and receiving. * Implement the weather display. * Test the mod. 5. **Test and Debug:** Thoroughly test the integration to ensure it works correctly and handles errors gracefully. **In summary, this is a complex project that requires a good understanding of Minecraft modding, networking, and APIs. Start with a simple implementation and gradually add features.** The provided code is a starting point and needs significant work to be functional. Good luck! Now, I'll translate the above response to Vietnamese.

glif-mcp

Gương của

ConnectWise Manage MCP Server

A Model Context Protocol (MCP) server for ConnectWise Manage API integration

Gmail MCP Server

Mirror of

🏆 LinkedIn DI MCP Server

Audiense Digital Intelligence LinkedIn MCP Server là một máy chủ dựa trên Giao thức Ngữ cảnh Mô hình (MCP), cho phép Claude và các ứng dụng khách tương thích MCP khác tương tác với tài khoản DI LinkedIn của bạn thông qua Audiense.