Discover Awesome MCP Servers

SharePoint MCP: The .NET MCP Server with Graph API & Semantic Kernel

Okay, I understand you want to create an **MCP (Managed Code Provider) server** to access **SharePoint Online**. However, the term "MCP server" in this context is a bit ambiguous. It's more likely you're looking for a way to interact with SharePoint Online programmatically using .NET code. Here's a breakdown of how to achieve this, focusing on the most common and recommended approaches: **Understanding the Goal** The core idea is to build a server-side application (likely a web API or a background service) that can: 1. **Authenticate** with SharePoint Online. 2. **Interact** with SharePoint Online (read, write, update, delete data). 3. **Expose** this functionality through an API or other interface that your client applications can use. **Key Technologies and Approaches** * **Microsoft Graph API:** This is the **recommended** approach for most modern SharePoint Online development. It provides a unified endpoint for accessing data and services across Microsoft 365, including SharePoint. * **PnP Framework (Patterns and Practices):** This is a community-driven open-source library that simplifies SharePoint development. It provides helper methods and extensions for working with both the SharePoint Client Object Model (CSOM) and the Microsoft Graph API. * **SharePoint Client Object Model (CSOM):** This is an older but still viable option. It allows you to interact with SharePoint Online using .NET code. However, Microsoft Graph is generally preferred for new development. **Example: Building a Web API using Microsoft Graph and .NET Core** This example demonstrates how to create a simple ASP.NET Core Web API that retrieves a list of SharePoint lists from a specific site. **1. Prerequisites:** * **.NET SDK:** Install the latest .NET SDK (e.g., .NET 7 or .NET 8). * **Azure Active Directory (Azure AD) App Registration:** You'll need to register an application in Azure AD to authenticate with SharePoint Online. **2. Azure AD App Registration:** * Go to the Azure portal ([portal.azure.com](portal.azure.com)). * Navigate to "Azure Active Directory" > "App registrations". * Click "New registration". * **Name:** Give your app a descriptive name (e.g., "SharePointOnlineAPI"). * **Supported account types:** Choose "Accounts in this organizational directory only" (or "Accounts in any organizational directory" if you need multi-tenant support). * **Redirect URI (optional):** For a Web API, you typically don't need a redirect URI. If you're building a client application that calls the API, you'll need to configure this later. * Click "Register". **Important App Registration Settings:** * **Application (client) ID:** Note this down. You'll need it in your code. * **Directory (tenant) ID:** Note this down. You'll need it in your code. * **Client Secret:** * Go to "Certificates & secrets" > "Client secrets". * Click "New client secret". * Add a description and choose an expiration date. * Click "Add". * **Copy the *value* of the client secret immediately.** You won't be able to see it again. Treat this like a password. * **API Permissions:** * Go to "API permissions" > "Add a permission". * Select "Microsoft Graph". * Choose "Application permissions" (because this is a server-side application). * Search for and select the following permissions (at a minimum): * `Sites.Read.All` (to read site information) * `Sites.ReadWrite.All` (if you need to write to sites) * `Files.Read.All` (to read files) * `Files.ReadWrite.All` (if you need to write files) * Click "Add permissions". * **Grant admin consent:** After adding the permissions, you'll need to grant admin consent for your organization. Click the "Grant admin consent for [Your Organization]" button. This requires administrator privileges. **3. Create the ASP.NET Core Web API Project:** ```bash dotnet new webapi -n SharePointOnlineAPI cd SharePointOnlineAPI ``` **4. Install Required NuGet Packages:** ```bash dotnet add package Microsoft.Identity.Web dotnet add package Microsoft.Graph dotnet add package Microsoft.Graph.Beta # Optional, for beta features ``` **5. Configure `appsettings.json`:** Add the following configuration to your `appsettings.json` file, replacing the placeholders with your actual values: ```json { "AzureAd": { "Instance": "https://login.microsoftonline.com/", "TenantId": "YOUR_TENANT_ID", "ClientId": "YOUR_CLIENT_ID", "ClientSecret": "YOUR_CLIENT_SECRET" }, "SharePoint": { "SiteUrl": "YOUR_SHAREPOINT_SITE_URL" // e.g., "https://yourtenant.sharepoint.com/sites/YourSite" }, "Logging": { "LogLevel": { "Default": "Information", "Microsoft.AspNetCore": "Warning" } }, "AllowedHosts": "*" } ``` **6. Create a `SharePointService` (or similar) to handle SharePoint interactions:** Create a new class (e.g., `SharePointService.cs`) to encapsulate the logic for interacting with SharePoint. ```csharp using Microsoft.Graph; using Microsoft.Identity.Web; using Microsoft.Extensions.Configuration; public class SharePointService { private readonly GraphServiceClient _graphClient; private readonly string _siteUrl; public SharePointService(GraphServiceClient graphClient, IConfiguration configuration) { _graphClient = graphClient; _siteUrl = configuration["SharePoint:SiteUrl"]; } public async Task<List<string>> GetListTitlesAsync() { try { // Extract the site ID from the Site URL var uri = new Uri(_siteUrl); string host = uri.Host; string relativePath = uri.AbsolutePath.TrimStart('/'); var site = await _graphClient.Sites.GetByPath(relativePath, host) .Request() .GetAsync(); var lists = await _graphClient.Sites[site.Id].Lists .Request() .GetAsync(); return lists.Select(l => l.DisplayName).ToList(); } catch (Exception ex) { // Log the exception properly Console.WriteLine($"Error getting lists: {ex}"); return new List<string>(); // Or throw the exception, depending on your needs } } } ``` **7. Configure Dependency Injection in `Program.cs`:** ```csharp using Microsoft.AspNetCore.Authentication.JwtBearer; using Microsoft.Identity.Web; using Microsoft.Graph; var builder = WebApplication.CreateBuilder(args); // Add authentication builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme) .AddMicrosoftIdentityWebApi(builder.Configuration.GetSection("AzureAd")); // Add services to the container. builder.Services.AddControllers(); // Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle builder.Services.AddEndpointsApiExplorer(); builder.Services.AddSwaggerGen(); // Configure Microsoft Graph builder.Services.AddScoped<GraphServiceClient>(sp => { var config = sp.GetRequiredService<IConfiguration>(); var tokenAcquisition = sp.GetRequiredService<ITokenAcquisition>(); return new GraphServiceClient(new DelegateAuthenticationProvider(async (requestMessage) => { var scopes = new[] { "Sites.Read.All" }; // Adjust scopes as needed string accessToken = await tokenAcquisition.GetAccessTokenForAppAsync(scopes); requestMessage.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", accessToken); })); }); // Register the SharePointService builder.Services.AddScoped<SharePointService>(); var app = builder.Build(); // Configure the HTTP request pipeline. if (app.Environment.IsDevelopment()) { app.UseSwagger(); app.UseSwaggerUI(); } app.UseHttpsRedirection(); app.UseAuthentication(); app.UseAuthorization(); app.MapControllers(); app.Run(); ``` **8. Create a Controller (e.g., `SharePointController.cs`):** ```csharp using Microsoft.AspNetCore.Authorization; using Microsoft.AspNetCore.Mvc; [Authorize] // Requires authentication [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly SharePointService _sharePointService; public SharePointController(SharePointService sharePointService) { _sharePointService = sharePointService; } [HttpGet("lists")] public async Task<IActionResult> GetLists() { var listTitles = await _sharePointService.GetListTitlesAsync(); return Ok(listTitles); } } ``` **9. Run the API:** ```bash dotnet run ``` **Explanation:** * **Azure AD Authentication:** The code uses `Microsoft.Identity.Web` to handle authentication with Azure AD. It retrieves an access token for the application using the client ID and client secret. * **Microsoft Graph Client:** The `GraphServiceClient` is used to make requests to the Microsoft Graph API. The `DelegateAuthenticationProvider` adds the access token to the `Authorization` header of each request. * **`SharePointService`:** This class encapsulates the logic for interacting with SharePoint. It retrieves the list titles from the specified site. * **Controller:** The `SharePointController` exposes an endpoint (`/sharepoint/lists`) that returns the list titles. The `[Authorize]` attribute ensures that only authenticated users can access the endpoint. * **Permissions:** The Azure AD app registration needs the `Sites.Read.All` permission (or more specific permissions if you only need to access certain sites). **Important Considerations:** * **Error Handling:** The example includes basic error handling, but you should implement more robust error handling in a production environment. Log exceptions properly and provide informative error messages to the client. * **Security:** Protect your client secret. Don't store it directly in your code. Use environment variables or Azure Key Vault to store it securely. * **Permissions:** Request only the permissions that your application needs. Avoid requesting broad permissions if you only need to access specific resources. * **Throttling:** SharePoint Online has throttling limits. Implement retry logic to handle throttling errors. Consider using the Microsoft Graph throttling guidance. * **PnP Framework:** For more complex scenarios, consider using the PnP Framework. It provides helper methods and extensions that can simplify your code. Install the `PnP.Framework` NuGet package. * **Asynchronous Operations:** Use `async` and `await` to avoid blocking the main thread. * **Configuration:** Use the `IConfiguration` interface to access configuration settings from `appsettings.json` or other configuration sources. * **Logging:** Implement proper logging to track errors and monitor the performance of your application. * **Deployment:** Deploy your Web API to a suitable hosting environment, such as Azure App Service. **Example using PnP Framework (Illustrative):** While the above example uses the Microsoft Graph directly, here's a snippet showing how PnP Framework can simplify things (this would require installing the `PnP.Framework` NuGet package and adjusting the `Program.cs` to inject the `IPnPContextFactory`): ```csharp using PnP.Framework; using Microsoft.AspNetCore.Mvc; using Microsoft.AspNetCore.Authorization; [Authorize] [ApiController] [Route("[controller]")] public class SharePointController : ControllerBase { private readonly IPnPContextFactory _pnpContextFactory; private readonly IConfiguration _configuration; public SharePointController(IPnPContextFactory pnpContextFactory, IConfiguration configuration) { _pnpContextFactory = pnpContextFactory; _configuration = configuration; } [HttpGet("lists-pnp")] public async Task<IActionResult> GetListsPnP() { string siteUrl = _configuration["SharePoint:SiteUrl"]; using (var pnpContext = await _pnpContextFactory.CreateAsync(new Uri(siteUrl))) { await pnpContext.Web.LoadAsync(p => p.Lists.QueryProperties(p => p.Title)); return Ok(pnpContext.Web.Lists.Select(l => l.Title).ToList()); } } } ``` **Key Differences with PnP:** * **Simplified Authentication:** PnP Framework often simplifies the authentication process, especially when using app-only authentication. The `IPnPContextFactory` handles the authentication behind the scenes. You'll still need to configure the Azure AD app registration and grant the necessary permissions. * **Fluent API:** PnP Framework provides a fluent API for interacting with SharePoint. This can make your code more readable and easier to maintain. * **CSOM Abstraction:** PnP Framework can abstract away some of the complexities of the SharePoint Client Object Model (CSOM). **Choosing the Right Approach:** * **New Development:** For new projects, **Microsoft Graph API is generally the preferred approach.** It's the modern, recommended way to interact with Microsoft 365 services. * **Existing CSOM Code:** If you have existing code that uses the SharePoint Client Object Model (CSOM), you can continue to use it. However, consider migrating to Microsoft Graph over time. * **Complexity:** PnP Framework can simplify development, especially for complex scenarios. It's a good choice if you want to reduce the amount of boilerplate code you need to write. **In summary, you're building a server-side application (likely a Web API) that authenticates with SharePoint Online using an Azure AD app registration and then uses either the Microsoft Graph API or the PnP Framework to interact with SharePoint data. The example above provides a starting point for building such an application.** Remember to adapt the code to your specific requirements and to implement proper error handling, security, and throttling management.

ETH Security MCP

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

Splunk MCP Server

Enables AI assistants to interact with Splunk Enterprise and Splunk Cloud instances through standardized MCP interface. Supports executing SPL queries, managing indexes and saved searches, listing applications, and retrieving server information with flexible authentication options.

MCP Python SDK Documentation

Here are a few ways to translate that, depending on the nuance you want to convey: **More literal:** * **Español:** Lee la documentación para el hackathon de MCP, la IA descentralizada del MIT. **Slightly more natural, emphasizing the "Read the docs" part:** * **Español:** Consulta la documentación del hackathon de MCP, la IA descentralizada del MIT. **Emphasizing the purpose of the documentation:** * **Español:** Lee la documentación para informarte sobre el hackathon de MCP, la IA descentralizada del MIT. **Which one is best depends on the context. If you're telling someone to go look up the information, the second option is probably best.**

MongoDB MCP Server for LLMs

A Model Context Protocol (MCP) server that enables LLMs to interact directly with MongoDB databases, allowing them to query collections, inspect schemas, and manage data seamlessly through natural language.

MCP Interface for Teenage Engineering EP-133 K.O. II

Here are a few ways you could translate "MCP Server for Teenage Engineering EP-133 KO-II" into Spanish, depending on the context: * **Servidor MCP para Teenage Engineering EP-133 KO-II:** This is a direct translation and is likely the best option if you're talking about a specific server application or software. "MCP" is often used as is in Spanish in technical contexts. * **Servidor de MCP para Teenage Engineering EP-133 KO-II:** This is also a direct translation, but it includes the "de" which can be more grammatically correct in some contexts. * **Servidor MCP para el EP-133 KO-II de Teenage Engineering:** This version reorders the phrase slightly to emphasize the EP-133 KO-II and uses "el" before the model number. The best option depends on the specific context of your conversation. If you are referring to a specific software or application, the first option is likely the best. If you are simply referring to a server that is compatible with the device, the second or third option may be more appropriate.

DadMCP

Servidor MCP remoto para brindar una mejor educación en casa.

Guardrail MCP Server

A minimal Model Context Protocol server that provides a safety guardrail tool to check if provided context is free from code injection or harmful content.

Screenshot Server

Enables capturing screenshots of web pages and local HTML files through a simple MCP tool interface using Puppeteer with configurable options for dimensions and output paths.

monday MCP Server

monday MCP Server

MCP RAG Server

Un servidor de Protocolo de Conversación con Máquinas que permite a los agentes de IA realizar Generación Aumentada por Recuperación (Retrieval-Augmented Generation) consultando una base de datos vectorial FAISS que contiene documentos del lenguaje Sui Move.

nativeMCP

Aquí hay un sistema MCP escrito en C++ que incluye la arquitectura central de MCP: host, cliente y servidor.

Google Search MCP

Una herramienta basada en Playwright que realiza búsquedas en Google y extrae resultados, evitando los mecanismos anti-bot, proporcionando capacidades de búsqueda en tiempo real para asistentes de IA.

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

Una implementación del protocolo de contexto del modelo (MCP) del lado del servidor que utiliza eventos enviados por el servidor (SSE) para la comunicación en tiempo real, proporcionando herramientas para cálculos y plantillas de recursos dinámicas.

MCP Play Sound Server

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

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

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

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.

mcp-server-test

Repositorio de prueba del servidor MCP

Email MCP Server by CData

This read-only MCP Server allows you to connect to Email data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

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!

Java based Model Context Procotol (MCP) Server for JDBC

Servidor de Protocolo de Contexto de Modelo (MCP) basado en Java para JDBC

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.

Monad NFT Analytics MCP

A server that retrieves NFT-related data on the Monad testnet, allowing users to check NFT holders, calculate portfolio values, view collections, and track top-selling NFTs by volume and sales across different time periods.