Discover Awesome MCP Servers

coalesce-transform-mcp

MCP server for Coalesce that manages nodes, pipelines, environments, jobs, and runs, and enables project validation, DDL/DML preview, deployment planning, and cloud environment application.

Project Tracking MCP Server

Enables project and task management through a lightweight SQLite database, allowing users to create projects, add categorized tasks, track status changes, and get project statistics through natural language commands.

mcp-server-apidebug

A standalone MCP server for API debugging, login authentication, API configuration management, and indexed API execution.

agentos-mcp-server

Governance kernel for AI agents — policy enforcement, code safety verification, multi-model hallucination detection (CMVK), trust attestation (IATP), and immutable audit trails. Works with Claude Desktop, Cursor, and any MCP client.

Directus MCP Server

Enables comprehensive interaction with Directus CMS including collection management, file operations, flow automation, user management, and schema analysis through natural language commands.

sahmk-mcp

Official MCP server for interacting with Saudi market data (Sahmk) via natural language queries, enabling stock quotes, company info, and market summaries inside AI agents like Cursor and Claude Desktop.

@lucairn/mcp-server

Privacy-preserving AI gateway. Sanitises PII before prompts reach Anthropic / OpenAI / your LLM, then emits a signed cryptographic certificate per call (Ed25519 + RFC 3161 + Sigstore Rekor). EU GDPR + AI Act ready. Free tier 500/mo with BYOK.

Git Auto Commit MCP Server

Analyzes git changes in repositories and generates conventional commit messages using OpenAI's GPT models, supporting both staged and unstaged changes with detailed summaries.

MCP Datastore Server

An MCP server that enables interaction with Google Firestore in Datastore mode for entity management and querying. It provides tools for CRUD operations, aggregation queries, and transaction execution within Google Cloud projects.

Ploomes MCP Server

Connects AI agents to the Ploomes CRM REST API, exposing 56 tools for managing contacts, deals, tasks, pipelines, interactions, quotes, orders, products, fields, users, and account information.

Almide MCP Server

Enables AI agents to compile, execute, and check Almide code for syntax or compilation errors. It provides tools for generating ASTs and accessing language grammar resources.

ROS MCP

Enables controlling robots in ROS environments through natural language, supporting topics, services, actions, and GUI tools.

SpaceBridge-MCP

A Model Context Protocol (MCP) server that integrates with the SpaceBridge REST API to automate issue management across connected issue trackers, allowing developers to manage issues directly from their AI-assisted coding environment.

Unrestricted Development MCP Server

Provides unrestricted access to your development environment with filesystem operations and shell command execution capabilities, including sudo support for local development machines.

Shopify Storefront MCP Server

Enables AI assistants to query and interact with Shopify store data via the Storefront API, including products, collections, carts, and customer information.

shivonai-mcp

Alat MCP kami dirancang untuk meningkatkan layanan wawancara otomatis berbasis AI dengan memastikan proses penilaian kandidat yang lancar dan relevan secara kontekstual. Alat-alat ini memanfaatkan model AI canggih untuk menganalisis respons, mengevaluasi kompetensi, dan memberikan umpan balik waktu nyata.

xkcd-mcp

MCP server to fetch xkcd comics (latest, random, by number, search) and display them with rich in-chat previews via the official JSON API and explainxkcd semantic search.

LinkedIn Outreach MCP Server

AI-powered content generation for LinkedIn outreach, helping sales teams and recruiters craft personalized connection requests, InMails, posts, comments, and multi-touch outreach sequences. It's a content assistant that generates text for human review and manual sending, fully compliant with LinkedIn's Terms of Service.

DivLens MCP

A real-time system diagnostics MCP server that gives AI agents live access to CPU, RAM, disk, network, processes, and hardware health metrics, with zero cloud dependency.

cargoshipper-mcp

A comprehensive MCP server that provides Claude with direct access to Docker, DigitalOcean, and CloudFlare APIs for infrastructure management and automation.

octo-mcp-server

A production-ready MCP server built with Node.js and Express that supports remote deployment via HTTP and SSE. It provides a modular framework for building and scaling tools while serving multiple clients concurrently.

freeqrcode-mcp-server

Enables AI assistants to generate QR codes for URLs, text, vCard, WiFi, email, and phone numbers with customizable size, colors, and error correction.

Multi-Agent Tools Platform

A modular production-ready system that provides specialized agents for math, research, weather, and summarization tasks through a unified MCP toolbox with smart supervisor capabilities.

Vanta MCP Server

Enables management of Vanta compliance platform resources including controls, vulnerabilities, vendors, and policies through natural language. Supports multi-tenant OAuth2 authentication for secure access to security and compliance data.

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.

🔐 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!

Desk3 MCP Server

Cryptocurrency MCP Server! Free! This powerful tool is designed for blockchain enthusiasts, providing comprehensive, real-time cryptocurrency information at your fingertips. Whether you're an experienced trader or just starting your journey into the crypto world.

memora

Persistent memory with knowledge graph visualization, semantic/hybrid search, importance scoring, and cloud sync (S3/R2) for cross-session context management.