fix: Ignore all certificates in MCP server

Author: pomianowski

Directory.Packages.props

@@ -6,6 +6,7 @@
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="9.0.7" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
+    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.7" />
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="9.0.7" />
     <PackageVersion Include="Microsoft.Extensions.Http.Resilience" Version="9.7.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />

Dockerfile

@@ -0,0 +1,24 @@
+# See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+# This stage is used when running from VS in fast mode (Default for Debug configuration)
+FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
+USER $APP_UID
+WORKDIR /app
+
+# This stage is used to build the service project
+FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
+WORKDIR /
+COPY . .
+RUN dotnet restore "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj"
+COPY . .
+RUN dotnet build "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj" -c Release -o /app/build
+
+# This stage is used to publish the service project to be copied to the final stage
+FROM build AS publish
+RUN dotnet publish "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj" -c Release -o /app/publish /p:UseAppHost=false
+
+# This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "OpenApi.Client.Mcp.dll"]

README.md

@@ -7,6 +7,42 @@ OpenAPI Client is a toolkit that helps you create HTTP clients for external APIs
 
 The repository contains NuGet package source code, which uses C# code generators that can be used to generate native C# API clients from YAML or JSON files.
 
+## MCP Server
+
+Build for yourself:
+
+```cmd
+docker buildx build ./ -f ./src/OpenApi.Client.Mcp/Dockerfile -t mcp/openapi --no-cache
+```
+
+or
+
+```cmd
+dotnet publish .\src\OpenApi.Client.Mcp\OpenApi.Client.Mcp.csproj -c Release /t:PublishContainer
+```
+
+Then
+
+```cmd
+docker run -d --name mcp-openapi mcp/openapi -e MODE=Stdio
+docker run -d --name mcp-openapi mcp/openapi -e MODE=Http -p 64622:8080
+```
+
+You can configure your *mcp.json* file
+
+```json
+{
+  "servers": {
+    "openapi.mcp": {
+      "type": "stdio",
+      "command": "docker",
+      "args": ["run", "-i", "--rm", "mcp/openapi"]
+    }
+  },
+  "inputs": []
+}
+```
+
 ## Gettings started
 
 OpenApiClient is available as NuGet package on NuGet.org:  

src/OpenApi.Client.Mcp/Configuration/ConfigurationFactory.cs

@@ -0,0 +1,59 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and OpenAPI Client Contributors.
+// All Rights Reserved.
+
+namespace OpenApi.Client.Mcp.Configuration;
+
+internal static class ConfigurationFactory
+{
+    public static ServerOptions CreateServerOptions(string[] args)
+    {
+        IConfigurationRoot configuration = CreateConfiguration(args);
+
+        string? mode =
+            configuration["Mode"]
+            ?? configuration["MODE"]
+            ?? configuration["mode"]
+            ?? configuration["Server:Mode"];
+
+        return new ServerOptions { Mode = ParseMode(mode) };
+    }
+
+    private static IConfigurationRoot CreateConfiguration(string[] args)
+    {
+        string environment =
+            Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")
+            ?? Environment.GetEnvironmentVariable("DOTNET_ENVIRONMENT")
+            ?? "Production";
+
+        IConfigurationBuilder builder = new ConfigurationBuilder()
+            .SetBasePath(AppContext.BaseDirectory)
+            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+            .AddJsonFile($"appsettings.{environment}.json", optional: true, reloadOnChange: true)
+            .AddEnvironmentVariables()
+            .AddCommandLine(args);
+
+        return builder.Build();
+    }
+
+    private static McpMode ParseMode(string? mode)
+    {
+        if (mode is null)
+        {
+            return McpMode.Stdio;
+        }
+
+        if (mode.Contains("both", StringComparison.InvariantCultureIgnoreCase))
+        {
+            return McpMode.Both;
+        }
+
+        if (mode.Contains("http", StringComparison.InvariantCultureIgnoreCase))
+        {
+            return McpMode.Http;
+        }
+
+        return McpMode.Stdio;
+    }
+}

src/OpenApi.Client.Mcp/Dockerfile

@@ -4,28 +4,18 @@
 FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base
 USER $APP_UID
 WORKDIR /app
-EXPOSE 8080
-
 
 # This stage is used to build the service project
 FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
-ARG BUILD_CONFIGURATION=Release
-WORKDIR /src
-COPY ["Directory.Packages.props", "."]
-COPY ["Directory.Build.props", "."]
-COPY ["Directory.Build.targets", "."]
-COPY ["nuget.config", "."]
-COPY ["src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj", "src/OpenApi.Client.Mcp/"]
-COPY ["src/OpenApi.Client.SourceGenerators/OpenApi.Client.SourceGenerators.csproj", "src/OpenApi.Client.SourceGenerators/"]
+WORKDIR /
+COPY . .
 RUN dotnet restore "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj"
 COPY . .
-WORKDIR "/src/src/OpenApi.Client.Mcp"
-RUN dotnet build "./OpenApi.Client.Mcp.csproj" -c $BUILD_CONFIGURATION -o /app/build
+RUN dotnet build "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj" -c Release -o /app/build
 
 # This stage is used to publish the service project to be copied to the final stage
 FROM build AS publish
-ARG BUILD_CONFIGURATION=Release
-RUN dotnet publish "./OpenApi.Client.Mcp.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false
+RUN dotnet publish "./src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj" -c Release -o /app/publish /p:UseAppHost=false
 
 # This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
 FROM base AS final

src/OpenApi.Client.Mcp/GlobalUsings.cs

@@ -3,22 +3,30 @@
 // Copyright (C) Leszek Pomianowski and OpenAPI Client Contributors.
 // All Rights Reserved.
 
+global using System;
+global using System.Collections.Generic;
+global using System.ComponentModel;
+global using System.Linq;
+global using System.Net.Http;
+global using System.Threading;
+global using System.Threading.Tasks;
 global using Microsoft.AspNetCore.Builder;
 global using Microsoft.CodeAnalysis;
 global using Microsoft.Extensions.Configuration;
 global using Microsoft.Extensions.DependencyInjection;
+global using Microsoft.Extensions.Hosting;
 global using Microsoft.Extensions.Logging;
+global using ModelContextProtocol.Protocol;
+global using ModelContextProtocol.Server;
 global using OpenApi.Client.Mcp.Configuration;
+global using OpenApi.Client.Mcp.Logging;
 global using OpenApi.Client.Mcp.Services;
 global using OpenApi.Client.Mcp.Tools;
+#if DEBUG
 global using OpenTelemetry;
 global using OpenTelemetry.Metrics;
 global using OpenTelemetry.Trace;
-global using System;
-global using System.Collections.Generic;
-global using System.ComponentModel;
-global using System.IO;
-global using System.Linq;
-global using System.Net.Http;
-global using System.Threading;
-global using System.Threading.Tasks;
+#endif
+#if !DEBUG
+global using Microsoft.AspNetCore.Hosting;
+#endif

src/OpenApi.Client.Mcp/Logging/StaticLoggerFactory.cs

@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and OpenAPI Client Contributors.
+// All Rights Reserved.
+
+namespace OpenApi.Client.Mcp.Logging;
+
+internal static class StaticLoggerFactory
+{
+    public static ILogger New(string category = "OpenAPI.Toolkit") =>
+        LoggerFactory
+            .Create(loggerBuilder =>
+            {
+                loggerBuilder.AddConsole(consoleLogOptions =>
+                {
+                    // Configure all logs to go to stderr
+                    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
+                });
+                loggerBuilder.SetMinimumLevel(LogLevel.Trace);
+            })
+            .CreateLogger(category);
+}

src/OpenApi.Client.Mcp/OpenApi.Client.Mcp.csproj

@@ -5,9 +5,14 @@
     <DockerfileContext>..\..</DockerfileContext>
     <ContainerDevelopmentMode>Fast</ContainerDevelopmentMode>
     <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+    <EnableSdkContainerSupport>true</EnableSdkContainerSupport>
+    <ContainerFamily>alpine</ContainerFamily>
+    <ContainerRepository>mcp/openapi</ContainerRepository>
+    <RuntimeIdentifiers>linux-x64;linux-arm64</RuntimeIdentifiers>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.Common" />
+    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" />
     <PackageReference Include="ModelContextProtocol" />
     <PackageReference Include="ModelContextProtocol.AspNetCore" />
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" />

src/OpenApi.Client.Mcp/Program.cs

@@ -3,66 +3,97 @@
 // Copyright (C) Leszek Pomianowski and OpenAPI Client Contributors.
 // All Rights Reserved.
 
-WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
+ILogger logger = StaticLoggerFactory.New();
+ServerOptions serverOptions = ConfigurationFactory.CreateServerOptions(args);
 
-builder.Logging.AddConsole(consoleLogOptions =>
-{
-    // Configure all logs to go to stderr
-    consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
-});
-
-#if DEBUG
-builder
-    .Services.AddOpenTelemetry()
-    .WithTracing(b => b.AddSource("*").AddAspNetCoreInstrumentation().AddHttpClientInstrumentation())
-    .WithMetrics(b => b.AddMeter("*").AddAspNetCoreInstrumentation().AddHttpClientInstrumentation())
-    .WithLogging()
-    .UseOtlpExporter();
-#endif
+logger.LogInformation("Configuring MCP Server with mode: {Mode}", serverOptions.Mode);
 
-builder.Services.AddTransient<IOpenApiService, OpenApiService>();
+// NOTE: Do not use whole ASP.NET stack with just interactive console
+if (serverOptions.Mode == McpMode.Stdio)
+{
+    logger.LogInformation("Adding Stdio transport to MCP Server.");
 
-builder.Services.AddHttpClient();
+    HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+    AddMcpServices(builder, serverOptions.Mode).WithStdioServerTransport();
 
-ServerOptions serverOptions = new();
-IConfigurationSection section = builder.Configuration.GetSection("Server");
-section.Bind(serverOptions);
+    logger.LogInformation("Starting the application.");
 
-string? mode = Environment.GetEnvironmentVariable("mode") ?? Environment.GetEnvironmentVariable("MODE");
+    await builder.Build().RunAsync();
 
-if (mode?.Contains("both", StringComparison.InvariantCultureIgnoreCase) ?? false)
-{
-    serverOptions.Mode = McpMode.Both;
-}
-else if (mode?.Contains("http", StringComparison.InvariantCultureIgnoreCase) ?? false)
-{
-    serverOptions.Mode = McpMode.Http;
+    // NOTE: Stop here, as we are running in Stdio mode.
+    return;
 }
 
-IMcpServerBuilder mcpBuilder = builder.Services.AddMcpServer();
+logger.LogInformation("Adding HTTP transport to MCP Server.");
+
+WebApplicationBuilder webBuilder = WebApplication.CreateBuilder(args);
+IMcpServerBuilder mcpBuilder = AddMcpServices(webBuilder, serverOptions.Mode).WithHttpTransport();
 
 if (serverOptions.Mode == McpMode.Both)
 {
-    _ = mcpBuilder.WithHttpTransport().WithStdioServerTransport();
-}
-else if (serverOptions.Mode == McpMode.Stdio)
-{
+    logger.LogInformation("Adding Stdio transport to MCP Server.");
     _ = mcpBuilder.WithStdioServerTransport();
 }
-else
-{
-    _ = mcpBuilder.WithHttpTransport();
-}
 
-_ = mcpBuilder.WithTools<OpenApiTools>();
+#if !DEBUG
+webBuilder.WebHost.ConfigureKestrel(options =>
+{
+    options.ListenAnyIP(80);
+    options.ListenAnyIP(8080);
+    options.ListenAnyIP(8000);
+});
+#endif
 
-await using WebApplication app = builder.Build();
+await using WebApplication app = webBuilder.Build();
 
-if (serverOptions.Mode is McpMode.Http or McpMode.Both)
-{
-    app.MapMcp();
-}
+app.MapMcp();
+app.MapHealthChecks("/healthz");
 
 await app.RunAsync();
 
 return;
+
+static IMcpServerBuilder AddMcpServices(IHostApplicationBuilder builder, McpMode mode)
+{
+    builder.Logging.AddConsole(consoleLogOptions =>
+    {
+        // Configure all logs to go to stderr
+        consoleLogOptions.LogToStandardErrorThreshold = LogLevel.Trace;
+    });
+
+#if DEBUG
+    builder
+        .Services.AddOpenTelemetry()
+        .WithTracing(b => b.AddSource("*").AddAspNetCoreInstrumentation().AddHttpClientInstrumentation())
+        .WithMetrics(b => b.AddMeter("*").AddAspNetCoreInstrumentation().AddHttpClientInstrumentation())
+        .WithLogging()
+        .UseOtlpExporter();
+#endif
+
+    builder
+        .Services.AddHttpClient<IOpenApiService, OpenApiService>()
+        .ConfigurePrimaryHttpMessageHandler(() =>
+        {
+            return new HttpClientHandler
+            {
+                ServerCertificateCustomValidationCallback = (_, _, _, _) => true,
+                AllowAutoRedirect = true,
+            };
+        });
+
+    if (mode != McpMode.Stdio)
+    {
+        builder.Services.AddHealthChecks();
+    }
+
+    IMcpServerBuilder mcpBuilder = builder
+        .Services.AddMcpServer(mcp =>
+        {
+            mcp.ServerInfo = new Implementation { Name = "OpenAPI Toolkit MCP Server", Version = "1.0.0" };
+            mcp.InitializationTimeout = TimeSpan.FromHours(1);
+            mcp.ScopeRequests = true;
+        })
+        .WithTools<OpenApiTools>();
+
+    return mcpBuilder;
+}