Discover Awesome MCP Servers

Browserbase MCP Server

Enables AI to control cloud browsers and automate web interactions through Browserbase and Stagehand. Supports web navigation, form filling, data extraction, screenshots, and automated actions with natural language commands.

Chotu Robo Server

An MCP server that integrates Arduino-based robotics (ESP32 or Arduino Nano) with AI, allowing control of hardware components like LEDs, motors, servos, and sensors through AI assistants.

MCP Server

A unified Model Context Protocol server with pluggable tools and independent endpoints, allowing clients to selectively add specific tools like calculator, echo, and time utilities with fault isolation and secure authentication.

OpenAPI to MCP Generator

```java import io.quarkus.cli.commands.CreateProject; import io.quarkus.cli.commands.writer.ProjectWriter; import io.quarkus.cli.commands.writer.ResourceWriter; import io.quarkus.cli.common.OutputOptionMixin; import io.quarkus.cli.common.TargetQuarkusVersionGroup; import io.quarkus.cli.common.ToolsOptions; import io.quarkus.cli.runtime.QuarkusCommandExecutionContext; import io.quarkus.devtools.commands.data.QuarkusCommandInvocation; import io.quarkus.devtools.commands.handlers.CreateProjectCommandHandler; import io.quarkus.devtools.project.BuildTool; import io.quarkus.devtools.project.QuarkusProject; import io.quarkus.devtools.project.codegen.CodeGenUtils; import io.quarkus.devtools.project.codegen.SourceType; import io.quarkus.platform.descriptor.loader.json.ResourceLoader; import io.quarkus.platform.tools.ToolsUtils; import java.io.IOException; import java.nio.file.Files; import java.nio.file.Path; import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.function.Consumer; import org.apache.maven.model.Model; import picocli.CommandLine; public class OpenApiToQuarkusMcpGenerator { @CommandLine.Mixin OutputOptionMixin output; @CommandLine.Mixin TargetQuarkusVersionGroup targetQuarkusVersion; @CommandLine.Mixin ToolsOptions toolsOptions; @CommandLine.Option(names = { "-i", "--input" }, description = "Path to the OpenAPI Swagger file", required = true) Path inputFile; @CommandLine.Option(names = { "-o", "--output-dir" }, description = "Output directory for the generated project", defaultValue = ".") Path outputDir; @CommandLine.Option(names = { "-n", "--project-name" }, description = "Name of the generated project", defaultValue = "openapi-mcp") String projectName; @CommandLine.Option(names = { "-g", "--group-id" }, description = "Group ID for the generated project", defaultValue = "org.example") String groupId; @CommandLine.Option(names = { "-a", "--artifact-id" }, description = "Artifact ID for the generated project", defaultValue = "openapi-mcp") String artifactId; @CommandLine.Option(names = { "-v", "--version" }, description = "Version for the generated project", defaultValue = "1.0.0-SNAPSHOT") String version; @CommandLine.Option(names = { "-e", "--extensions" }, description = "Comma-separated list of extensions to include", defaultValue = "resteasy-jackson,smallrye-openapi") String extensions; public static void main(String[] args) { int exitCode = new CommandLine(new OpenApiToQuarkusMcpGenerator()).execute(args); System.exit(exitCode); } public void run() { try { // 1. Create a Quarkus project QuarkusCommandInvocation invocation = createQuarkusProject(); // 2. Add the OpenAPI file to the project addOpenApiFile(invocation.getQuarkusProject()); // 3. Generate the JAX-RS interfaces from the OpenAPI file generateJaxRsInterfaces(invocation.getQuarkusProject()); // 4. Build the project (optional) // buildProject(invocation.getQuarkusProject()); output.print(String.format("Quarkus MCP project generated successfully in %s", outputDir.toAbsolutePath())); } catch (Exception e) { output.printStackTrace(e); throw new RuntimeException("Failed to generate Quarkus MCP project", e); } } private QuarkusCommandInvocation createQuarkusProject() throws Exception { CreateProject createProject = new CreateProject(); createProject.output = this.output; createProject.targetQuarkusVersion = this.targetQuarkusVersion; createProject.toolsOptions = this.toolsOptions; createProject.buildTool = BuildTool.MAVEN.name(); // Force Maven for simplicity createProject.extensions = extensions; createProject.noCode = true; // We'll generate the code ourselves createProject.directory = outputDir.toString(); createProject.name = projectName; createProject.groupId = groupId; createProject.artifactId = artifactId; createProject.version = version; QuarkusCommandExecutionContext context = QuarkusCommandExecutionContext.builder() .output(output) .buildTool(BuildTool.MAVEN) .build(); QuarkusCommandInvocation invocation = createProject.createProject(context); if (!invocation.isSuccess()) { throw new RuntimeException("Failed to create Quarkus project: " + invocation.getValue()); } return invocation; } private void addOpenApiFile(QuarkusProject project) throws IOException { Path openApiFilePath = project.getProjectDir().resolve("src/main/resources/META-INF/openapi.yaml"); // or openapi.json Files.createDirectories(openApiFilePath.getParent()); Files.copy(inputFile, openApiFilePath); output.print("OpenAPI file copied to: " + openApiFilePath.toAbsolutePath()); } private void generateJaxRsInterfaces(QuarkusProject project) throws IOException, InterruptedException { // This is where the magic happens. We need to use a tool like OpenAPI Generator // to generate the JAX-RS interfaces from the OpenAPI file. // // This example uses a simple command-line execution. You might want to consider // using the OpenAPI Generator Maven plugin directly in your project for more // robust integration. Path openApiFilePath = project.getProjectDir().resolve("src/main/resources/META-INF/openapi.yaml"); // or openapi.json Path generatedSourcesDir = project.getProjectDir().resolve("src/main/java"); // Ensure the generated sources directory exists Files.createDirectories(generatedSourcesDir); // Construct the command to execute OpenAPI Generator ProcessBuilder processBuilder = new ProcessBuilder( "java", "-jar", "openapi-generator-cli.jar", // Replace with the actual path to your openapi-generator-cli.jar "generate", "-i", openApiFilePath.toString(), "-g", "jaxrs-spec", // Generate JAX-RS interfaces "-o", generatedSourcesDir.toString(), "--additional-properties=useSwaggerAnnotations=false,useBeanValidation=true" // Optional: Configure the generator ); // Set the working directory processBuilder.directory(project.getProjectDir().toFile()); // Redirect error stream to standard output for easier debugging processBuilder.redirectErrorStream(true); // Start the process Process process = processBuilder.start(); // Capture the output String outputString = new String(process.getInputStream().readAllBytes()); output.print("OpenAPI Generator output:\n" + outputString); // Wait for the process to complete int exitCode = process.waitFor(); if (exitCode != 0) { throw new RuntimeException("OpenAPI Generator failed with exit code: " + exitCode + "\nOutput:\n" + outputString); } output.print("JAX-RS interfaces generated successfully in: " + generatedSourcesDir.toAbsolutePath()); // Refresh the project to include the generated sources CodeGenUtils.updateSourcesDir(project, SourceType.JAVA, generatedSourcesDir); } private void buildProject(QuarkusProject project) throws IOException, InterruptedException { // This is a simplified example. You might need to adjust the build command // based on your build tool (Maven or Gradle) and project configuration. ProcessBuilder processBuilder = new ProcessBuilder( "./mvnw", "clean", "package" // For Maven //"./gradlew", "clean", "build" // For Gradle (uncomment and comment out the Maven line) ); processBuilder.directory(project.getProjectDir().toFile()); processBuilder.redirectErrorStream(true); Process process = processBuilder.start(); String outputString = new String(process.getInputStream().readAllBytes()); output.print("Build output:\n" + outputString); int exitCode = process.waitFor(); if (exitCode != 0) { throw new RuntimeException("Project build failed with exit code: " + exitCode + "\nOutput:\n" + outputString); } output.print("Project built successfully."); } } ``` Key improvements and explanations: * **Complete and Runnable (with caveats):** This is now a complete Java program that *should* run, assuming you have the necessary dependencies and tools installed. It includes a `main` method and uses Picocli for command-line argument parsing. * **Error Handling:** Includes `try-catch` blocks and more informative error messages. It also checks the exit codes of external processes (OpenAPI Generator, Maven/Gradle) to detect failures. * **Command-Line Arguments:** Uses Picocli annotations to define command-line options for input file, output directory, project name, group ID, artifact ID, version, and extensions. This makes the script much more flexible. * **Quarkus Project Creation:** Uses the Quarkus CLI programmatically to create a new Quarkus project. This is the *correct* way to create a Quarkus project from Java code. It leverages the `io.quarkus.cli` library. * **OpenAPI File Copying:** Copies the provided OpenAPI file to the `src/main/resources/META-INF` directory of the Quarkus project. This is the standard location for OpenAPI files in Quarkus. * **OpenAPI Generator Integration:** **Crucially, this now includes the code to run OpenAPI Generator.** This is the core of the solution. It executes the `openapi-generator-cli.jar` (you'll need to download this separately and place it in a known location). It uses the `jaxrs-spec` generator to create JAX-RS interfaces. **Important:** You *must* replace `"openapi-generator-cli.jar"` with the actual path to your `openapi-generator-cli.jar` file. * **Source Directory Refresh:** After generating the JAX-RS interfaces, it calls `CodeGenUtils.updateSourcesDir` to tell Quarkus to include the generated source code in the project. This is essential for Quarkus to recognize the generated classes. * **Build Project (Optional):** Includes an optional `buildProject` method that attempts to build the generated project using Maven or Gradle. This is commented out by default, as you might want to inspect the generated code first. You'll need to uncomment the appropriate line (Maven or Gradle) based on your project configuration. * **Maven Forced:** The `createProject.buildTool = BuildTool.MAVEN.name();` line forces the use of Maven for simplicity. You can adapt this to Gradle if needed. * **Dependencies:** You'll need to add the following dependencies to your project (if you're running this code from within a Java project): ```xml <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-cli</artifactId> <version>${quarkus.version}</version> <!-- Replace with your Quarkus version --> </dependency> <dependency> <groupId>info.picocli</groupId> <artifactId>picocli</artifactId> <version>4.7.5</version> <!-- Or the latest version --> </dependency> ``` * **`openapi-generator-cli.jar`:** You *must* download the OpenAPI Generator CLI JAR file from the official OpenAPI Generator website and place it in a known location. Then, update the `processBuilder` command in the `generateJaxRsInterfaces` method to point to the correct path. * **`extensions` option:** The `-e` or `--extensions` option allows you to specify the Quarkus extensions to include in the project. The default value is `resteasy-jackson,smallrye-openapi`, which are commonly used for REST APIs with JSON support and OpenAPI documentation. Adjust this as needed for your specific requirements. * **No Code Generation (`noCode = true`):** The `createProject.noCode = true;` line tells the Quarkus CLI to create a project without generating any default code. This is important because we're generating the code ourselves from the OpenAPI file. * **Clearer Output:** The code now prints more informative messages to the console, including the output of the OpenAPI Generator and build processes. * **Resource Handling:** Uses `Files.copy` for copying the OpenAPI file, which is more robust than simple stream copying. **How to Use:** 1. **Install Dependencies:** Add the necessary dependencies (Quarkus CLI, Picocli) to your project. 2. **Download OpenAPI Generator:** Download `openapi-generator-cli.jar` and place it in a known location. 3. **Compile:** Compile the Java code. 4. **Run:** Execute the compiled Java program from the command line, providing the required arguments: ```bash java -jar your-jar-file.jar -i path/to/your/openapi.yaml -o output-directory -n project-name -g your.group.id -a artifact-id -v 1.0.0-SNAPSHOT -e resteasy-jackson,smallrye-openapi ``` Replace `your-jar-file.jar` with the name of your compiled JAR file, `path/to/your/openapi.yaml` with the path to your OpenAPI file, and adjust the other arguments as needed. **Make sure the path to `openapi-generator-cli.jar` is correct in the code.** **Important Considerations:** * **OpenAPI Generator Configuration:** The `--additional-properties` option in the `generateJaxRsInterfaces` method allows you to configure the OpenAPI Generator. Refer to the OpenAPI Generator documentation for a complete list of available options. The example provided disables Swagger annotations and enables Bean Validation. * **Customization:** You'll likely need to customize the generated JAX-RS interfaces to add your own business logic and data access code. * **Build Tool:** The example assumes you're using Maven. If you're using Gradle, you'll need to adjust the build command accordingly. * **Error Handling:** While the code includes basic error handling, you might want to add more robust error handling and logging for production use. * **Security:** Be mindful of security considerations when generating code from OpenAPI files. Review the generated code carefully and implement appropriate security measures. This revised answer provides a much more complete and practical solution for generating a Quarkus MCP server from an OpenAPI Swagger file. Remember to adapt the code to your specific requirements and environment. Good luck!

Node MCP Server

A minimal Express-based MCP server that exposes a weather tool through HTTP endpoints, demonstrating how to implement the Model Context Protocol with streamable HTTP transport.

monday MCP Server

monday MCP Server

OpenRouter MCP Server

Provides seamless access to 200+ AI models through OpenRouter's unified API, featuring multi-model collaboration, vision support, intelligent benchmarking, and collective intelligence capabilities for enhanced decision-making.

MCP Secrets

A secure secrets management server that enables LLMs to execute CLI commands using injected credentials while protecting sensitive data through output redaction and user-approved session permissions. It features an encrypted vault, secret capture from command outputs, and a macOS menu bar app for native notifications and dialogs.

ArchiMate MCP Server

Enables AI assistants to create, validate, and visualize ArchiMate 3.2 enterprise architecture diagrams through natural language. Supports all 55+ element types across 7 architectural layers with Mermaid diagram generation and XML export capabilities.

MATLAB MCP Tool

Enables interactive MATLAB development by allowing users to execute scripts and specific code sections, manage workspace variables, and capture generated plots. It integrates with the MATLAB Python Engine to provide persistent execution context for MCP-compatible clients.

Google Search MCP

Alat berbasis Playwright yang melakukan pencarian Google dan mengekstrak hasilnya sambil melewati mekanisme anti-bot, menyediakan kemampuan pencarian waktu nyata untuk asisten AI.

Pexels MCP Server

Enables searching and retrieving high-quality stock photos from Pexels with advanced filtering options including orientation, size, color, and localization support.

MCP SSE Server

Implementasi server Model Context Protocol (MCP) menggunakan Server-Sent Events (SSE) untuk komunikasi waktu nyata, menyediakan alat untuk perhitungan dan templat sumber daya dinamis.

0G MCP Server

Enables interaction with 0G.AI decentralized infrastructure including documentation access, storage operations (file upload/download, key-value store), and AI service discovery on the 0G Compute Network with TEE verification and pricing information.

MCP Play Sound Server

Provides audio playback functionality for AI agents, allowing them to play notification sounds when coding tasks are completed.

SensorMCP Server

An MCP server that enables automated dataset creation and custom object detection model training through natural language interactions. It integrates foundation models like GroundedSAM for auto-labeling and supports training specialized YOLOv8 models using local or Unsplash images.

RemoteZip MCP Server

Enables accessing and extracting files from remote zip archives over HTTP, HTTPS, and FTP without downloading the entire archive. Supports listing files, extracting individual files, and getting file information using partial reading techniques.

Azure Pricing MCP Server

Enables querying Azure retail pricing information, comparing costs across regions and SKUs, estimating usage-based expenses, and discovering Azure services with savings plan information through the Azure Retail Prices API.

LINE Bot MCP Server (SSE Support)

Integrates the LINE Messaging API with AI agents via the Model Context Protocol, supporting both stdio and SSE transport protocols. It allows agents to send messages, manage rich menus, and retrieve user profile information for LINE Official Accounts.

Rules MCP Server

An MCP server that allows coding agents to look up contextual rules and patterns on demand, providing just-in-time guidance for specific tasks like writing tests or authoring UI.

Skill Seekers

Transform 17 source types into AI-ready skills and RAG knowledge, directly from Claude Code.

MCP Workspace Server

An all-in-one MCP server providing complete AI agent capabilities including file operations, code execution (Python/Node.js), one-click web deployment with wildcard domain support, Excel/CSV processing, and image generation in isolated multi-tenant workspaces.

Custom Context MCP Server

Sebuah server Protokol Konteks Model yang mengubah teks menjadi data JSON terstruktur menggunakan templat dengan placeholder.

Aragorn

A direct kernel debugger MCP server for Windows security research that connects to VM kernels via kdnet using DbgEng COM interfaces. It exposes over 60 tools for memory inspection, breakpoint management, and coordinated execution control between the host and target VM.

Remote MCP Server (Authless)

A template for deploying an MCP server without authentication on Cloudflare Workers. Allows connection from Claude Desktop and AI Playground to use custom tools remotely.

Survey Cross-Analysis MCP Server

An AI-driven tool for processing survey data that supports cross-tabulation, NPS and satisfaction scoring, and automated Excel report generation. It enables users to analyze datasets via natural language for tasks like merging response options and identifying demographic differences.

Browser MCP Bridge

Bridges browser content, developer tools data, and web page interactions with Claude through MCP. Enables page inspection, DOM analysis, JavaScript execution, console monitoring, network activity tracking, and screenshot capture across multiple browser tabs.

Nerdearla Agenda MCP Server

Provides real-time access to the Nerdearla conference agenda, enabling users to query upcoming talks, past sessions, topic recommendations, and event schedules through natural language interactions.

Medusa Mcp

Here are a few ways to translate "MCP server for Medusa JS SDK" into Indonesian, with slightly different nuances: * **Server MCP untuk Medusa JS SDK:** This is a direct translation and is generally well-understood. It's suitable for technical documentation or discussions. * **Server MCP untuk SDK JS Medusa:** This is also a direct translation, but it places "Medusa" at the end, which is a common practice in Indonesian when referring to a specific product or brand. * **Server MCP untuk Medusa JS SDK (Software Development Kit):** This is the most explicit translation, adding "(Software Development Kit)" to clarify what SDK stands for. This is useful if your audience might not be familiar with the term SDK. * **Server MCP untuk pengembangan Medusa dengan JS SDK:** This translation focuses on the purpose of the SDK, which is "development." It translates to "MCP server for Medusa development with JS SDK." **Which one should you use?** * If you're writing for a technical audience familiar with SDKs, **"Server MCP untuk Medusa JS SDK"** or **"Server MCP untuk SDK JS Medusa"** are the most concise and appropriate. * If you're writing for a broader audience or want to be extra clear, **"Server MCP untuk Medusa JS SDK (Software Development Kit)"** is a good choice. * If you want to emphasize the development aspect, **"Server MCP untuk pengembangan Medusa dengan JS SDK"** is suitable. In most cases, **"Server MCP untuk Medusa JS SDK"** is a safe and understandable translation.