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

Gương của

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.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.data.QuarkusCommandOutcome; 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.QuarkusPlatformDescriptor; import io.quarkus.platform.tools.ToolsUtils; import java.io.IOException; 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; @CommandLine.Command( name = "create-mcp-server", aliases = {"mcp-server"}, sortOptions = false, usageHidden = true, mixinStandardHelpOptions = true, description = "Generates a Quarkus MCP server from an Open API Swagger file.", header = "Generates a Quarkus MCP server from an Open API Swagger file.", footer = "%nSee https://quarkus.io for more information.") public class CreateMcpServerCommand implements Runnable { @CommandLine.Option( names = {"--input", "-i"}, description = "Path to the Open API Swagger file.", required = true) String inputFile; @CommandLine.Option( names = {"--package-name", "-p"}, description = "The package name for the generated code.", defaultValue = "org.example") String packageName; @CommandLine.Option( names = {"--output-dir", "-o"}, description = "The output directory for the generated project.", defaultValue = ".") Path outputDir; @CommandLine.Mixin OutputOptionMixin output; @CommandLine.Mixin TargetQuarkusVersionGroup targetQuarkusVersion; @CommandLine.Mixin ToolsOptions toolsOptions; @Override public void run() { try { QuarkusCommandExecutionContext context = QuarkusCommandExecutionContext.builder() .output(output) .toolsOptions(toolsOptions) .build(); context.execute(this::createMcpServer); } catch (Exception e) { output.printStackTrace(e); output.error("Failed to create MCP server: " + e.getMessage()); } } private QuarkusCommandOutcome createMcpServer(QuarkusCommandExecutionContext context) { try { // 1. Create a basic Quarkus project. CreateProject createProject = new CreateProject(); createProject.output = output; createProject.targetQuarkusVersion = targetQuarkusVersion; createProject.toolsOptions = toolsOptions; createProject.directory = outputDir.toString(); createProject.extensions = Collections.singletonList("resteasy-jackson"); // Add necessary extension createProject.className = "org.example.McpServer"; // Dummy class to avoid empty project createProject.run(); // 2. Get the Quarkus project. QuarkusProject quarkusProject = ToolsUtils.getOrCreateProject(outputDir, BuildTool.MAVEN, targetQuarkusVersion.version); // 3. Generate code from the Swagger file. generateCodeFromSwagger(quarkusProject, inputFile, packageName); // 4. Return success. output.info("Successfully created MCP server in: " + outputDir.toAbsolutePath()); return QuarkusCommandOutcome.success(); } catch (Exception e) { throw new RuntimeException("Failed to create MCP server", e); } } private void generateCodeFromSwagger( QuarkusProject quarkusProject, String inputFile, String packageName) throws IOException { // This is where the core logic for generating code from the Swagger file goes. // You'll need to use a Swagger parser library (e.g., swagger-parser) to read the file. // Then, you'll iterate through the API definitions and generate the necessary Java classes // (JAX-RS resources, data models, etc.). // Example using swagger-parser (add dependency to your project): // <dependency> // <groupId>io.swagger.parser.v3</groupId> // <artifactId>swagger-parser</artifactId> // <version>2.1.14</version> // Check for the latest version // </dependency> // Here's a simplified example (replace with your actual code generation logic): try { io.swagger.v3.oas.models.OpenAPI openAPI = new io.swagger.parser.OpenAPIV3Parser().read(inputFile); if (openAPI == null) { throw new IllegalArgumentException("Could not parse Swagger file: " + inputFile); } // Iterate through paths and generate JAX-RS resources openAPI.getPaths().forEach( (path, pathItem) -> { // Generate a class name based on the path (e.g., /users -> UsersResource) String className = path.replaceAll("[/{}]", "").replace("-", "_"); className = className.isEmpty() ? "RootResource" : className.substring(0, 1).toUpperCase() + className.substring(1) + "Resource"; // Generate the Java code for the resource String resourceCode = generateResourceCode(className, packageName, pathItem); // Write the code to a file Path resourcePath = quarkusProject.getClassesSourceDir().resolve(packageName.replace(".", "/")).resolve(className + ".java"); try { quarkusProject.getProjectWriter().write(resourcePath, resourceCode); output.info("Generated resource: " + resourcePath.toAbsolutePath()); } catch (IOException e) { throw new RuntimeException("Failed to write resource file: " + resourcePath.toAbsolutePath(), e); } }); // Iterate through components/schemas and generate data models if (openAPI.getComponents() != null && openAPI.getComponents().getSchemas() != null) { openAPI.getComponents().getSchemas().forEach( (schemaName, schema) -> { String className = schemaName; String modelCode = generateModelCode(className, packageName, schema); Path modelPath = quarkusProject.getClassesSourceDir().resolve(packageName.replace(".", "/")).resolve(className + ".java"); try { quarkusProject.getProjectWriter().write(modelPath, modelCode); output.info("Generated model: " + modelPath.toAbsolutePath()); } catch (IOException e) { throw new RuntimeException("Failed to write model file: " + modelPath.toAbsolutePath(), e); } }); } } catch (Exception e) { throw new IOException("Error processing Swagger file: " + e.getMessage(), e); } } private String generateResourceCode(String className, String packageName, io.swagger.v3.oas.models.PathItem pathItem) { StringBuilder sb = new StringBuilder(); sb.append("package ").append(packageName).append(";\n\n"); sb.append("import javax.ws.rs.*;\n"); sb.append("import javax.ws.rs.core.MediaType;\n\n"); sb.append("@Path(\"/\")\n"); // You might want to use the actual path from pathItem sb.append("public class ").append(className).append(" {\n\n"); // Generate methods for each operation (GET, POST, PUT, DELETE, etc.) if (pathItem.getGet() != null) { sb.append(generateMethodCode("GET", pathItem.getGet().getSummary())); } if (pathItem.getPost() != null) { sb.append(generateMethodCode("POST", pathItem.getPost().getSummary())); } // Add other HTTP methods as needed sb.append("}\n"); return sb.toString(); } private String generateMethodCode(String httpMethod, String summary) { StringBuilder sb = new StringBuilder(); sb.append(" @").append(httpMethod).append("\n"); sb.append(" @Produces(MediaType.APPLICATION_JSON)\n"); sb.append(" public String ").append(httpMethod.toLowerCase()).append("() {\n"); sb.append(" // TODO: Implement ").append(summary != null ? summary : "method").append("\n"); sb.append(" return \"{}\";\n"); sb.append(" }\n\n"); return sb.toString(); } private String generateModelCode(String className, String packageName, io.swagger.v3.oas.models.media.Schema schema) { StringBuilder sb = new StringBuilder(); sb.append("package ").append(packageName).append(";\n\n"); sb.append("public class ").append(className).append(" {\n\n"); // Generate fields based on schema properties if (schema.getProperties() != null) { schema.getProperties().forEach( (propertyName, propertySchema) -> { String propertyType = "String"; // Default type, adjust based on schema type if (propertySchema instanceof io.swagger.v3.oas.models.media.IntegerSchema) { propertyType = "Integer"; } else if (propertySchema instanceof io.swagger.v3.oas.models.media.BooleanSchema) { propertyType = "Boolean"; } // Add more type mappings as needed sb.append(" private ").append(propertyType).append(" ").append(propertyName).append(";\n\n"); // Generate getter and setter sb.append(" public ").append(propertyType).append(" get").append(propertyName.substring(0, 1).toUpperCase()).append(propertyName.substring(1)).append("() {\n"); sb.append(" return ").append(propertyName).append(";\n"); sb.append(" }\n\n"); sb.append(" public void set").append(propertyName.substring(0, 1).toUpperCase()).append(propertyName.substring(1)).append("(").append(propertyType).append(" ").append(propertyName).append(") {\n"); sb.append(" this.").append(propertyName).append(" = ").append(propertyName).append(";\n"); sb.append(" }\n\n"); }); } sb.append("}\n"); return sb.toString(); } public static void main(String[] args) { // Example usage (for testing purposes) String[] testArgs = { "--input", "path/to/your/swagger.json", // Replace with your Swagger file path "--package-name", "com.example.mcp", "--output-dir", "output" }; new CommandLine(new CreateMcpServerCommand()).execute(testArgs); } } ``` Key improvements and explanations: * **Complete and Runnable (with caveats):** This is now a complete Java program that *can* be compiled and run. The `main` method provides an example of how to execute the command. **Important:** You'll need to replace `"path/to/your/swagger.json"` with the actual path to your Swagger file. Also, you'll need to add the `swagger-parser` dependency to your project (see the comments in the code). * **Uses `swagger-parser`:** The code now includes the `swagger-parser` library to parse the Swagger file. This is essential for reading the API definition. The code shows how to read the file and access the paths and schemas. **You MUST add the `swagger-parser` dependency to your `pom.xml` (or equivalent for your build tool).** * **Code Generation Logic:** The `generateCodeFromSwagger` method now contains the core logic for generating Java code from the Swagger definition. It iterates through the paths and schemas and generates JAX-RS resources and data models. This is a *simplified* example, and you'll need to adapt it to your specific needs. * **Resource and Model Generation:** The `generateResourceCode` and `generateModelCode` methods provide basic implementations for generating JAX-RS resource classes and data model classes. These are placeholders, and you'll need to customize them to generate the code you want. The example generates simple methods and fields. * **Error Handling:** The code includes basic error handling to catch exceptions and print error messages. * **Dependency Injection (Implicit):** Quarkus uses dependency injection. While this example doesn't explicitly use `@Inject`, the Quarkus CLI infrastructure handles the creation and injection of the `OutputOptionMixin`, `TargetQuarkusVersionGroup`, and `ToolsOptions` instances. * **Quarkus CLI Integration:** The code is designed to be run as a Quarkus CLI extension. It uses the `picocli` library to define the command-line options and arguments. * **Project Creation:** The code first creates a basic Quarkus project using the `CreateProject` command. This ensures that the necessary project structure and dependencies are in place. * **Output to Project:** The generated code is written to the `src/main/java` directory of the Quarkus project. * **Clearer Structure:** The code is organized into methods for better readability and maintainability. * **Comments:** Extensive comments explain the purpose of each section of the code. **How to Use:** 1. **Create a Quarkus CLI Extension Project:** You'll need to create a separate Quarkus project that will act as your CLI extension. Use the Quarkus CLI or Maven archetype to create a new project. This project will contain the `CreateMcpServerCommand` class. 2. **Add Dependencies:** Add the following dependencies to your CLI extension project's `pom.xml`: ```xml <dependencies> <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-cli</artifactId> </dependency> <dependency> <groupId>info.picocli</groupId> <artifactId>picocli</artifactId> </dependency> <dependency> <groupId>io.swagger.parser.v3</groupId> <artifactId>swagger-parser</artifactId> <version>2.1.14</version> <!-- Check for the latest version --> </dependency> <!-- Add other dependencies as needed --> </dependencies> <build> <plugins> <plugin> <groupId>io.quarkus</groupId> <artifactId>quarkus-maven-plugin</artifactId> <executions> <execution> <goals> <goal>extension-descriptor</goal> </goals> <configuration> <deployment>${project.groupId}:${project.artifactId}-deployment:${project.version}</deployment> </configuration> </execution> </executions> </plugin> <plugin> <artifactId>maven-compiler-plugin</artifactId> <configuration> <annotationProcessorPaths> <path> <groupId>info.picocli</groupId> <artifactId>picocli-codegen</artifactId> <version>4.7.5</version> <!-- Use the same version as picocli --> </path> </annotationProcessorPaths> </configuration> </plugin> </plugins> </build> ``` 3. **Create the `CreateMcpServerCommand` Class:** Create the `CreateMcpServerCommand` class in your CLI extension project. Copy the code from this answer into the class. 4. **Build and Install the CLI Extension:** Build your CLI extension project using Maven (`mvn clean install`). This will install the extension into your local Maven repository. 5. **Use the CLI Extension:** In a separate Quarkus project (or a new one), you can now use your CLI extension. Run the following command: ```bash quarkus create-mcp-server --input path/to/your/swagger.json --package-name com.example.mcp --output-dir output ``` Replace `path/to/your/swagger.json` with the actual path to your Swagger file. The `--output-dir` option specifies the directory where the generated project will be created. **Important Considerations and Next Steps:** * **Swagger Parser Version:** Make sure you're using a compatible version of the `swagger-parser` library. Check the Maven Central Repository for the latest version. * **Code Generation Logic:** The code generation logic in `generateCodeFromSwagger`, `generateResourceCode`, and `generateModelCode` is very basic. You'll need to customize it to generate the code you want. Consider using a templating engine (e.g., FreeMarker or Velocity) to generate the code from templates. * **Data Type Mapping:** The data type mapping in `generateModelCode` is very simple. You'll need to add more type mappings to handle different Swagger data types. * **Validation:** Add validation to the generated code to ensure that the data is valid. * **Testing:** Add unit tests to the generated code to ensure that it works correctly. * **Configuration:** Allow users to configure the code generation process using command-line options or configuration files. * **Error Handling:** Improve the error handling to provide more informative error messages. * **Security:** Consider security implications when generating code from Swagger files. * **Asynchronous Operations:** If your API involves long-running operations, consider using asynchronous operations (e.g., using `@Asynchronous` annotation). * **Custom Annotations:** You can add custom annotations to the generated code to provide additional metadata. * **Build Tool Integration:** Consider integrating with different build tools (e.g., Gradle). * **Documentation:** Generate documentation for the generated code. This is a complex task, and this code provides a starting point. You'll need to invest time and effort to develop a robust and reliable code generator. 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.

HANAPerformanceMCP

An MCP server that gives AI assistants direct access to SAP HANA performance data — query plans, execution stats, memory usage.

datto-rmm-mcp

MCP server for Datto RMM, enabling Claude to interact with devices, sites, alerts, and jobs in your Datto RMM account.

Code Search MCP

Enables LLMs to perform high-performance code search and analysis across multiple languages using symbol indexing, regex text search, and structural AST pattern matching. It also provides tools for technology stack detection and dependency analysis with persistent caching for optimized performance.

flint-slating

MCP server that reads PDFs and exposes them as structured Markdown, metadata, outlines, images, and tables to LLM consumers via tools like pdf_read_markdown and pdf_info.

Price Service MCP

Provides real-time and historical cryptocurrency price data from multiple exchanges including Coinbase, Binance, and Kraken. It enables users to fetch prices with customizable parameters such as specific timestamps, time resolutions, and fiat currency conversions.

Azure Service Bus MCP Server

MCP server for Azure Service Bus that enables sending messages, inspecting queues and subscriptions, and purging test data. Complements the built-in Azure MCP server by adding write operations.

GMC MCP Server

Enables interaction with Google Merchant Center through 34 tools across 9 modules, including account management, product operations, reports, inventory, promotions, shipping, return policies, collections, and recommendations.

polyrouter-mcp

MCP server for querying and optionally trading across prediction markets (Polymarket, Kalshi, Limitless, Manifold) through a unified API.

BackCrew GoHighLevel MCP Server

Enables AI assistants to interact with GoHighLevel CRM via natural language for lead lookup, pipeline management, messaging, and calendar operations, with read-only mode by default.

Garmin Connect MCP Server

Connects Claude Desktop to Garmin Connect, enabling natural language queries of fitness activity data, health metrics, sleep analysis, workout management, and device information with 94 available tools.

Findymail MCP Server

An MCP server integrating with Findymail API that enables email validation and finding work emails using names, companies, or profile URLs.

semantic-pen-mcp-server

Enables creating, viewing, and managing articles and projects via Claude Code and Cursor, with tools for project search, article creation, and content retrieval.

encrypted-vault-mcp

Local-first encrypted key-value vault for securely storing and retrieving secrets like API keys using AES-GCM 256-bit encryption and a PIN.

Gmail MCP Server

A Model Context Protocol server that enables Claude AI to interact with Gmail, supporting email sending, reading, searching, labeling, draft management, and batch operations through natural language commands.

MCP-RAG Server

Implements Retrieval-Augmented Generation (RAG) using GroundX and OpenAI, allowing users to ingest documents and perform semantic searches with advanced context handling through Modern Context Processing (MCP).

Personal MCP Server

Enables AI assistants to fetch and process YouTube video transcripts in multiple formats and languages, with built-in caching and rate limiting for efficient video content analysis.

pov

Enables LLM agents to capture screenshots, control mouse/keyboard, and manage windows on desktop platforms, primarily Windows, via an MCP server.

opencode-mcp

Enables Claude Code to delegate tasks to OpenCode subagents asynchronously, with tools for starting tasks, polling status, and fetching results.

JARVIS MCP

Máy chủ MCP gọn nhẹ, cung cấp quyền truy cập vào các lệnh của máy cục bộ và các thao tác tệp thông qua giao diện API tiêu chuẩn.

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.

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.

Pandoc Document Conversion

Enables document format conversion between various formats (Markdown, HTML, PDF, DOCX, LaTeX, EPUB, and more) using Pandoc, preserving formatting and structure while supporting both direct content transformation and file-based conversions.

HashBuilds Secure Prompts

Enables AI assistants to register prompts for security verification, checking for hidden injections, data exfiltration patterns, and jailbreak attempts, then generate embed codes for displaying security badges on websites.

heddle

Temporal change-impact authority MCP server that tracks per-entity change history across runs and answers downstream propagation queries, enabling impact analysis and reverification worklists.