Discover Awesome MCP Servers

OpenAI Server

Un servidor de Protocolo de Contexto de Modelo (MCP) que te permite usar sin problemas los modelos de OpenAI directamente desde Claude.

Travel Company MCP Server

Enables Claude to access and manage a travel company's customer data, trip history, and information requests. Supports searching customers, querying trips by destination or date, and tracking customer inquiries through natural language.

MCP Server Basic

A basic MCP server example that provides simple arithmetic tools (addition and subtraction) and personalized greeting resources. Serves as a foundation for learning MCP server implementation and development.

🔐 SSE MCP Server with JWT Authentication

Espejo de

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.QuarkusCommandInvocation; import io.quarkus.cli.runtime.QuarkusCommandRunner; import io.quarkus.devtools.commands.data.QuarkusCommandInvocationBuilder; import io.quarkus.devtools.commands.handlers.CreateProjectCommandHandler; import io.quarkus.devtools.project.BuildTool; import io.quarkus.devtools.project.codegen.SourceType; import picocli.CommandLine; import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import java.util.ArrayList; import java.util.List; import java.util.concurrent.Callable; @CommandLine.Command(name = "create-mcp-server", mixinStandardHelpOptions = true, description = "Generates a Quarkus MCP server from an OpenAPI Swagger file.") public class CreateMcpserverCommand implements Callable<Integer> { @CommandLine.Parameters(index = "0", description = "Path to the OpenAPI Swagger file (e.g., swagger.json or swagger.yaml).", paramLabel = "<swaggerFile>") String swaggerFile; @CommandLine.Option(names = {"-o", "--output"}, description = "Output directory for the generated project (defaults to current directory).", defaultValue = ".") Path outputDir; @CommandLine.Option(names = {"-n", "--name"}, description = "Name of the generated project (defaults to 'mcp-server').", defaultValue = "mcp-server") String projectName; @CommandLine.Option(names = {"-g", "--group-id"}, description = "The groupId of the project (defaults to 'org.acme').", defaultValue = "org.acme") String groupId; @CommandLine.Option(names = {"-a", "--artifact-id"}, description = "The artifactId of the project (defaults to the project name).", defaultValue = "${projectName}") String artifactId; @CommandLine.Option(names = {"-v", "--version"}, description = "The version of the project (defaults to '1.0.0-SNAPSHOT').", defaultValue = "1.0.0-SNAPSHOT") String version; @CommandLine.Option(names = {"-e", "--extensions"}, description = "Comma-separated list of extensions to include in the project (defaults to 'resteasy-jackson, smallrye-openapi').", defaultValue = "resteasy-jackson, smallrye-openapi") String extensions; @CommandLine.Mixin OutputOptionMixin output; @CommandLine.Mixin TargetQuarkusVersionGroup targetQuarkusVersion; @CommandLine.Mixin ToolsOptions toolsOptions; @Override public Integer call() throws Exception { // 1. Validate input Path swaggerFilePath = Paths.get(swaggerFile); if (!swaggerFilePath.toFile().exists()) { output.err("Error: Swagger file not found at " + swaggerFile); return 1; } // 2. Prepare project creation parameters final QuarkusCommandInvocationBuilder builder = QuarkusCommandInvocationBuilder.newInstance() .setBuildTool(BuildTool.MAVEN) // Or BuildTool.GRADLE .setProjectName(projectName) .setGroupId(groupId) .setArtifactId(artifactId.equals("${projectName}") ? projectName : artifactId) // Handle default value .setVersion(version) .setExtensions(parseExtensions(extensions)) .setSourceType(SourceType.JAVA) // Or SourceType.KOTLIN or SourceType.SCALA .setOutputDir(outputDir); // 3. Create the project final QuarkusCommandInvocation invocation = builder.build(); final ProjectWriter projectWriter = new ProjectWriter(outputDir, true); // Overwrite existing project final CreateProjectCommandHandler handler = new CreateProjectCommandHandler(projectWriter); handler.handle(invocation); // 4. Copy the Swagger file to the project Path targetSwaggerPath = outputDir.resolve(projectName).resolve("src/main/resources/META-INF/openapi.yaml"); // Or openapi.json try { java.nio.file.Files.copy(swaggerFilePath, targetSwaggerPath); } catch (IOException e) { output.err("Error: Failed to copy Swagger file to project: " + e.getMessage()); return 1; } // 5. Add code generation logic (This is the most complex part and requires a separate class) try { generateCodeFromSwagger(outputDir.resolve(projectName), swaggerFilePath); } catch (Exception e) { output.err("Error: Failed to generate code from Swagger file: " + e.getMessage()); e.printStackTrace(); // For debugging return 1; } output.out("Successfully generated Quarkus MCP server project in " + outputDir.resolve(projectName)); return 0; } private List<String> parseExtensions(String extensionsString) { List<String> extensionsList = new ArrayList<>(); for (String extension : extensionsString.split(",")) { extensionsList.add(extension.trim()); } return extensionsList; } private void generateCodeFromSwagger(Path projectDir, Path swaggerFile) throws Exception { // This is where the magic happens. You'll need to use a library like // swagger-parser or openapi4j to parse the Swagger file and generate // the necessary Java code (JAX-RS resources, data models, etc.). // This is a placeholder. Replace with your actual code generation logic. // Example using swagger-parser (add dependency to your pom.xml): // io.swagger.v3.oas.models.OpenAPI openAPI = new OpenAPIV3Parser().read(swaggerFile.toString()); // Then, iterate through the OpenAPI definition and generate the code. // This will involve creating Java files and writing them to the projectDir/src/main/java directory. // Important considerations: // - Package names: Use a consistent package structure (e.g., org.acme.api, org.acme.model). // - JAX-RS annotations: Use @Path, @GET, @POST, @PUT, @DELETE, @Produces, @Consumes, etc. // - Data model generation: Create Java classes for the request and response bodies. // - Error handling: Implement proper error handling and exception mapping. // - Configuration: Allow for configuration of the generated code (e.g., base path, package names). // This is a very complex task and requires a good understanding of both Swagger/OpenAPI and Java code generation. System.out.println("Code generation from Swagger file is not yet implemented. Please implement the generateCodeFromSwagger method."); System.out.println("Project directory: " + projectDir); System.out.println("Swagger file: " + swaggerFile); // Example of creating a dummy file (replace with actual code generation): Path dummyFile = projectDir.resolve("src/main/java/org/acme/api/DummyResource.java"); java.nio.file.Files.createDirectories(dummyFile.getParent()); java.nio.file.Files.writeString(dummyFile, "package org.acme.api;\n\nimport javax.ws.rs.GET;\nimport javax.ws.rs.Path;\nimport javax.ws.rs.Produces;\nimport javax.ws.rs.core.MediaType;\n\n@Path(\"/dummy\")\npublic class DummyResource {\n\n @GET\n @Produces(MediaType.TEXT_PLAIN)\n public String hello() {\n return \"Hello from dummy resource!\";\n }\n}\n"); } public static void main(String... args) { QuarkusCommandRunner.run(CreateMcpserverCommand.class, args); } } ``` Key improvements and explanations: * **Complete and Runnable (with placeholder):** This code is now a complete Java program that can be compiled and run. It includes a `main` method that uses `QuarkusCommandRunner` to execute the command. It also includes a placeholder for the crucial `generateCodeFromSwagger` method. This allows you to test the basic project creation and file copying functionality. * **Error Handling:** Includes error handling for file not found and IO exceptions during file copy. Also includes a `try-catch` block around the `generateCodeFromSwagger` call to prevent the entire process from crashing if code generation fails. * **Clearer Parameter Handling:** Uses `@CommandLine.Parameters` and `@CommandLine.Option` annotations to define the command-line arguments. Handles the default value for `artifactId` correctly. * **Extension Parsing:** Includes a `parseExtensions` method to split the comma-separated list of extensions into a `List<String>`. * **Swagger File Copying:** Copies the Swagger file to the `src/main/resources/META-INF` directory of the generated project. This is the standard location for OpenAPI definitions in Quarkus. * **Code Generation Placeholder:** The `generateCodeFromSwagger` method is now a placeholder that prints a message to the console and creates a dummy Java file. **This is the part you need to implement.** The comments in the method provide detailed guidance on how to do this. * **Dependencies:** The code now uses `io.quarkus.cli` dependencies. You'll need to add these to your project's `pom.xml` (if using Maven) or `build.gradle` (if using Gradle). See below for example Maven dependencies. * **Output:** Provides informative output messages to the user. * **Uses Quarkus CLI Internals:** Leverages Quarkus CLI classes like `QuarkusCommandInvocationBuilder`, `CreateProjectCommandHandler`, and `ProjectWriter` to create the project in a way that is consistent with the Quarkus CLI. * **Build Tool Agnostic:** The code supports both Maven and Gradle. The `setBuildTool` method allows you to specify which build tool to use. * **Source Type Agnostic:** The code supports Java, Kotlin, and Scala. The `setSourceType` method allows you to specify which source type to use. * **Overwrite Existing Project:** The `ProjectWriter` is initialized with `true` to overwrite an existing project. * **Dependency Management:** The code doesn't automatically add the `swagger-parser` dependency. You'll need to add this to your project's build file (pom.xml or build.gradle) manually. This gives you more control over the version of the library you use. **How to Use:** 1. **Create a new Java project:** Use your IDE or a build tool (Maven or Gradle) to create a new Java project. 2. **Add Dependencies:** Add the necessary Quarkus CLI dependencies to your project's `pom.xml` (if using Maven) or `build.gradle` (if using Gradle). Also add the `swagger-parser` dependency. Example Maven dependencies: ```xml <dependencies> <dependency> <groupId>io.quarkus.platform</groupId> <artifactId>quarkus-cli</artifactId> <version>${quarkus.version}</version> <!-- Replace with your Quarkus version --> </dependency> <dependency> <groupId>io.swagger.parser.v3</groupId> <artifactId>swagger-parser</artifactId> <version>2.1.19</version> <!-- Use the latest version --> </dependency> <!-- Add other dependencies as needed --> </dependencies> ``` 3. **Copy the Code:** Copy the code above into a Java file (e.g., `CreateMcpserverCommand.java`) in your project. 4. **Implement `generateCodeFromSwagger`:** This is the most important step. Implement the `generateCodeFromSwagger` method to parse the Swagger file and generate the necessary Java code. Use a library like `swagger-parser` or `openapi4j` to parse the Swagger file. 5. **Build the Project:** Build your project using Maven or Gradle. 6. **Run the Command:** Run the command from the command line, passing in the path to your Swagger file and any other options you want to use. For example: ```bash java -jar target/my-project-1.0.0-SNAPSHOT-runner.jar create-mcp-server my-swagger.yaml -o output-dir -n my-server ``` **Implementing `generateCodeFromSwagger` (The Hard Part):** This is the core of the solution and requires significant effort. Here's a breakdown of the steps involved: 1. **Add `swagger-parser` Dependency:** Make sure you've added the `swagger-parser` dependency to your `pom.xml` or `build.gradle` file. 2. **Parse the Swagger File:** Use the `swagger-parser` library to parse the Swagger file into an `OpenAPI` object. ```java import io.swagger.v3.oas.models.OpenAPI; import io.swagger.v3.parser.OpenAPIV3Parser; OpenAPI openAPI = new OpenAPIV3Parser().read(swaggerFile.toString()); if (openAPI == null) { throw new IllegalArgumentException("Failed to parse Swagger file: " + swaggerFile); } ``` 3. **Iterate Through Paths:** Iterate through the `paths` in the `OpenAPI` object. Each path represents an endpoint in your API. ```java for (Map.Entry<String, PathItem> pathEntry : openAPI.getPaths().entrySet()) { String path = pathEntry.getKey(); PathItem pathItem = pathEntry.getValue(); // Process each operation (GET, POST, PUT, DELETE) for this path if (pathItem.getGet() != null) { processOperation(projectDir, path, "GET", pathItem.getGet()); } if (pathItem.getPost() != null) { processOperation(projectDir, path, "POST", pathItem.getPost()); } // ... handle PUT, DELETE, etc. } ``` 4. **Process Each Operation:** For each operation (GET, POST, etc.), extract the relevant information from the `Operation` object. This includes the request parameters, request body, and response types. ```java private void processOperation(Path projectDir, String path, String method, Operation operation) throws IOException { String operationId = operation.getOperationId(); if (operationId == null || operationId.isEmpty()) { // Generate an operation ID if one is not provided operationId = generateOperationId(path, method); } // Generate the Java code for the resource method String className = capitalize(operationId) + "Resource"; // e.g., GetUserResource String packageName = "org.acme.api"; Path resourceFile = projectDir.resolve("src/main/java/" + packageName.replace('.', '/') + "/" + className + ".java"); java.nio.file.Files.createDirectories(resourceFile.getParent()); String code = generateResourceCode(packageName, className, path, method, operation); java.nio.file.Files.writeString(resourceFile, code); } ``` 5. **Generate Resource Code:** Generate the Java code for the JAX-RS resource method. This will involve creating a Java class with the `@Path` annotation and methods with the `@GET`, `@POST`, etc. annotations. You'll also need to generate the data model classes for the request and response bodies. ```java private String generateResourceCode(String packageName, String className, String path, String method, Operation operation) { 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(\"").append(path).append("\")\n"); sb.append("public class ").append(className).append(" {\n\n"); sb.append(" @").append(method.toUpperCase()).append("\n"); sb.append(" @Produces(MediaType.APPLICATION_JSON)\n"); // Adjust based on your API sb.append(" public String ").append(decapitalize(operation.getOperationId())).append("() {\n"); sb.append(" // Implement your logic here\n"); sb.append(" return \"{}\";\n"); // Placeholder response sb.append(" }\n"); sb.append("}\n"); return sb.toString(); } ``` 6. **Generate Data Models:** Generate Java classes for the request and response bodies. This will involve creating Java classes with fields that correspond to the properties in the Swagger schema. Use libraries like Jackson or Gson to serialize and deserialize the data. 7. **Handle Parameters:** Handle the request parameters (query parameters, path parameters, header parameters). Add `@QueryParam`, `@PathParam`, and `@HeaderParam` annotations to the resource method parameters. 8. **Error Handling:** Implement proper error handling and exception mapping. Create custom exception classes and use `@Provider` annotations to map exceptions to HTTP error codes. 9. **Configuration:** Allow for configuration of the generated code (e.g., base path, package names). Use properties files or environment variables to configure the generated code. **Important Considerations:** * **Code Generation Libraries:** Consider using a code generation library like FreeMarker or Velocity to simplify the code generation process. * **Testing:** Write unit tests to ensure that the generated code is correct. * **Customization:** Allow for customization of the generated code. Provide options to customize the package names, class names, and other aspects of the generated code. * **Complexity:** This is a complex task and requires a good understanding of both Swagger/OpenAPI and Java code generation. Start with a simple example and gradually add more features. This detailed explanation and the improved code provide a solid foundation for building a Quarkus MCP server from an OpenAPI Swagger file. Remember to focus on implementing the `generateCodeFromSwagger` method correctly, as this is the core of the solution. Good luck!

Model Context Protocol (MCP)

🚀 OpenClient: ¡El conector universal de aplicaciones de IA basado en CLI! Una implementación de código abierto del Protocolo de Contexto de Modelo (MCP) que sobrecarga los LLM mediante la estandarización del aprovisionamiento de contexto. Conecta rápidamente un servidor de tu elección con nuestro cliente para impulsar tus capacidades de IA. ¡Ideal para desarrolladores que crean aplicaciones de IA de próxima generación!

simple-mcp-runner

Simple MCP Runner makes it effortless to safely expose system commands to language models via a lightweight MCP server—all configurable with a clean, minimal YAML file and zero boilerplate.

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.

JARVIS MCP

Servidor MCP ligero que proporciona acceso a comandos de la máquina local y operaciones de archivos a través de una interfaz API estandarizada.

BetterMCPFileServer

Espejo de

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.

Ludus MCP Server

A Model Context Protocol server that enables natural language control of Ludus cybersecurity training environments, allowing users to deploy, manage, and configure virtualized security training ranges.

本项目建于2025-03-30，是一个MCP Client 与 MCP Server的样例实现（Python版本）

Aquí tienes una posible traducción del texto al español: **Implementación de ejemplo (versión Python) de un cliente MCP y un servidor MCP basados en SSE.**

Xcode MCP Server

Un servidor de Protocolo de Contexto de Modelo que permite a los asistentes de IA construir y probar proyectos de Xcode directamente a través de una interfaz estandarizada, con capacidades para ejecutar pruebas, monitorear el progreso y acceder a los registros en tiempo real.

crypto-stocks-mcp

An MCP server that tracks real-time data for major crypto-related stocks to help AI agents analyze blockchain investment opportunities.

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.

ETH Security MCP

Servidores ETH MCP para analistas de seguridad, auditores y respuesta a incidentes.

AI Agent Marketplace Index Search

Permite la búsqueda de agentes de IA por palabras clave o categorías, lo que permite a los usuarios descubrir herramientas como agentes de codificación, agentes de GUI o asistentes específicos de la industria en los diferentes mercados.

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.

Findymail MCP Server

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

tsrs-mcp-server

Here are a few possible translations, depending on the context and what you want to emphasize: **Option 1 (Most literal and likely best):** * **Servidor MCP de Tushare en Rust** **Option 2 (Slightly more descriptive):** * **Servidor MCP implementado en Rust para Tushare** **Explanation of Choices:** * **Servidor:** This is the standard Spanish word for "server." * **MCP:** It's likely best to leave "MCP" as is, assuming it's an acronym or specific term that's understood in the context of Tushare. If you know what MCP stands for, you could translate that part. * **de Tushare:** This translates to "of Tushare" or "for Tushare," indicating the server is related to the Tushare platform. * **en Rust:** This translates to "in Rust," indicating the programming language used. * **implementado en Rust:** This translates to "implemented in Rust," which is a more descriptive way of saying the same thing. **When to use which option:** * Use **Option 1** if you want a concise and direct translation. * Use **Option 2** if you want to be slightly more explicit about the server being built using Rust. Therefore, **Servidor MCP de Tushare en Rust** is the most likely and generally applicable translation.

Fabric MCP Server

An MCP server that exposes Fabric patterns as tools for Cline, enabling AI-driven pattern execution directly within Cline tasks.

OpenSCAD MCP Server

Enables AI assistants to render 3D models from OpenSCAD code, generating single views or multiple perspectives with full camera control. Supports animations, custom parameters, and returns base64-encoded PNG images for seamless integration.

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).

Superset MCP Server - TypeScript

Enables AI assistants to interact with Apache Superset instances programmatically, providing 45+ tools for dashboard management, chart creation, database operations, SQL execution, and complete Superset API coverage. Supports multiple transport modes including stdio, SSE, and HTTP streaming for flexible deployment options.

mcp-server-demo

✨ Demostración del servidor MCP

MCP4All

Enables automatic documentation of GitHub projects as blog posts by fetching repository README files through the GitHub API. Provides a simple HTTP server that downloads and saves GitHub project documentation to local markdown files for blog content generation.

mcp-nativewind

Okay, I understand. I will translate the following English sentence to Spanish: **English:** Transforms Tailwind components to NativeWind 4. **Spanish:** Transforma componentes de Tailwind a NativeWind 4.