Discover Awesome MCP Servers

Linear MCP Server

An open-source Model Context Protocol server that enables interaction with the Linear API to manage issues, teams, and comments. It allows users to create, update, and search for issues while accessing workspace users and workflow states.

🔐 SSE MCP Server with JWT Authentication

Cermin dari

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!

Redmine MCP Server

Enables natural language interaction with Redmine via Claude Code or other MCP clients, supporting project, issue, and wiki management.

vworld-mcp

Enables to query South Korean cadastral and land information (parcel boundaries, land use zones, official land prices) via VWorld Open API, supporting geocoding, reverse geocoding, and location search for real estate feasibility reviews.

YOLO-FFMPEG-MCP

An AI-powered MCP server for intelligent video processing, enabling automated analysis, transition effects, and quality assurance with multi-agent orchestration.

Zoho CRM Integration

Connects Claude to Zoho CRM with read-only access, enabling natural language queries to search records, list modules, retrieve field information, and count records using OAuth authentication.

salaxy-mcp

Exposes Finnish payroll (palkanlaskenta) API as MCP tools for calculating salaries, retrieving income types, and fetching mock employee data.

Model Context Protocol (MCP)

🚀 OpenClient - Konektor Aplikasi AI Universal Berbasis CLI! Implementasi Model Context Protocol (MCP) sumber terbuka yang mempercepat LLM dengan standarisasi penyediaan konteks. Hubungkan dengan cepat server pilihan Anda dengan klien kami untuk meningkatkan kemampuan AI Anda. Ideal untuk pengembang yang menciptakan aplikasi AI generasi berikutnya!

Chrome DevTools MCP

Lets AI coding assistants control and inspect a live Chrome browser using full Chrome DevTools capabilities for browser automation, debugging, and performance analysis.

artemis-mcp-server

An MCP server that lets an AI agent work with an ActiveMQ Artemis broker.

Chosun MCP

MCP server for querying Chosun University portal, CLC/e-Class, and OJ systems, providing tools to access academic information, timetables, notices, and more.

Bruno MCP Server

A Model Context Protocol (MCP) server that enables programmatic creation and management of Bruno API testing collections, environments, and requests through standardized MCP tools.

geocontext

An experimental MCP server providing spatial context for LLMs by interfacing with French Geoplateforme services. It enables tasks such as geocoding, altitude lookups, and querying administrative, cadastral, or urban planning data.

InfluxDB OSS API MCP Server

An MCP server that enables interactions with InfluxDB's open-source time-series database API, allowing data querying, management, and operations through natural language.

obs-mcp

Model Context Protocol server for OBS Studio

solidity-sentinel

Enables static security audit of Solidity smart contracts by analyzing source code or deployed bytecode for vulnerabilities, providing risk scores and detailed findings.

vlm-mcp-server

An MCP server providing vision and video analysis tools, configurable with any model provider.

Shatale MCP Server

AI-native payment infrastructure that enables AI agents to make purchases, issue virtual cards, and manage spending within delegated budgets and policy controls.

Bandcamp MCP

Enables searching and browsing Bandcamp for albums, artists, tracks, and tags, as well as discovering new music by genre and format.

aws-s3-universal-mcp-server

A standardized interface for interacting with AWS S3 tools and services through a unified API, following the MCP specification.

HandsAI Bridge

A Node.js MCP server that acts as a communication bridge for the HandsAI Java application, enabling socket-based integration between MCP clients and the HandsAI main server.

House Rules

Provides reusable AI assistant behavior rules as prompts and automatic git repository context (branch, commits, diffstat) to eliminate repetitive explanations across sessions and clients.

ZAI MCP Server

Provides web search, content extraction, and AI summarization capabilities using the GLM-4.7-Flash model. It enables users to perform web searches, fetch website data, and generate concise content summaries through integrated tools.

Sparkle MCP Server

Provides secure file access and clipboard history management for Claude AI and other MCP-compatible clients, with sandboxed file operations and search capabilities.

MCP Marketing Agency

Specialized MCP server for digital marketing and social media management, enabling content generation, hashtag optimization, planning, analytics, and engagement strategies.

YouTube Shorts & Instagram Reels MCP Server

Enables automated posting of videos to YouTube Shorts and Instagram Reels with OAuth 2.0 authentication, file validation, and comprehensive video processing capabilities. Provides MCP-compatible tools for seamless social media video uploads through a FastAPI server.

stackchan-mcp

Bridges MCP-compatible AI assistants with the Stack-chan robot, enabling speech, listening, vision, movement, and facial expressions through MCP tool calls.

MCP Logback Analyzer

A FastMCP-based tool for analyzing logback log files to detect code defects and generate automated fix suggestions. It features intelligent stack trace filtering and token optimization to efficiently identify and resolve application errors.