Add ModelContextProtocol.AspNetCore

ModelContextProtocol.sln

@@ -50,6 +50,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuickstartWeatherServer", "
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "QuickstartClient", "samples\QuickstartClient\QuickstartClient.csproj", "{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ModelContextProtocol.AspNetCore", "src\ModelContextProtocol.AspNetCore\ModelContextProtocol.AspNetCore.csproj", "{37B6A5E0-9995-497D-8B43-3BC6870CC716}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -92,6 +94,10 @@ Global
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA}.Release|Any CPU.Build.0 = Release|Any CPU
+		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{37B6A5E0-9995-497D-8B43-3BC6870CC716}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -107,6 +113,7 @@ Global
 		{0C6D0512-D26D-63D3-5019-C5F7A657B28C} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{4653EB0C-8FC0-98F4-E9C8-220EDA7A69DF} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
 		{0D1552DC-E6ED-4AAC-5562-12F8352F46AA} = {02EA681E-C7D8-13C7-8484-4AC65E1B71E8}
+		{37B6A5E0-9995-497D-8B43-3BC6870CC716} = {A2F1F52A-9107-4BF8-8C3F-2F6670E7D0AD}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {384A3888-751F-4D75-9AE5-587330582D89}

samples/AspNetCoreSseServer/AspNetCoreSseServer.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\ModelContextProtocol\ModelContextProtocol.csproj" />
+    <ProjectReference Include="..\..\src\ModelContextProtocol.AspNetCore\ModelContextProtocol.AspNetCore.csproj" />
   </ItemGroup>
 
 </Project>

samples/AspNetCoreSseServer/Program.cs

@@ -1,10 +1,9 @@
-using AspNetCoreSseServer;
+using ModelContextProtocol.AspNetCore;
 
 var builder = WebApplication.CreateBuilder(args);
 builder.Services.AddMcpServer().WithToolsFromAssembly();
 var app = builder.Build();
 
-app.MapGet("/", () => "Hello World!");
-app.MapMcpSse();
+app.MapMcp();
 
 app.Run();

src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs

@@ -0,0 +1,118 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using ModelContextProtocol.Protocol.Messages;
+using ModelContextProtocol.Protocol.Transport;
+using ModelContextProtocol.Server;
+using ModelContextProtocol.Utils.Json;
+using System.Collections.Concurrent;
+using System.Security.Cryptography;
+
+namespace ModelContextProtocol.AspNetCore;
+
+/// <summary>
+/// Extension methods for <see cref="IEndpointRouteBuilder"/> to add MCP endpoints.
+/// </summary>
+public static class McpEndpointRouteBuilderExtensions
+{
+    /// <summary>
+    /// Sets up endpoints for handling MCP HTTP Streaming transport.
+    /// </summary>
+    /// <param name="endpoints">The web application to attach MCP HTTP endpoints.</param>
+    /// <param name="runSession">Provides an optional asynchronous callback for handling new MCP sessions.</param>
+    /// <returns>Returns a builder for configuring additional endpoint conventions like authorization policies.</returns>
+    public static IEndpointConventionBuilder MapMcp(this IEndpointRouteBuilder endpoints, Func<HttpContext, IMcpServer, CancellationToken, Task>? runSession = null)
+    {
+        ConcurrentDictionary<string, SseResponseStreamTransport> _sessions = new(StringComparer.Ordinal);
+
+        var loggerFactory = endpoints.ServiceProvider.GetRequiredService<ILoggerFactory>();
+        var mcpServerOptions = endpoints.ServiceProvider.GetRequiredService<IOptions<McpServerOptions>>();
+
+        var routeGroup = endpoints.MapGroup("");
+
+        routeGroup.MapGet("/sse", async context =>
+        {
+            var response = context.Response;
+            var requestAborted = context.RequestAborted;
+
+            response.Headers.ContentType = "text/event-stream";
+            response.Headers.CacheControl = "no-cache";
+
+            var sessionId = MakeNewSessionId();
+            await using var transport = new SseResponseStreamTransport(response.Body, $"/message?sessionId={sessionId}");
+            if (!_sessions.TryAdd(sessionId, transport))
+            {
+                throw new Exception($"Unreachable given good entropy! Session with ID '{sessionId}' has already been created.");
+            }
+            await using var server = McpServerFactory.Create(transport, mcpServerOptions.Value, loggerFactory, endpoints.ServiceProvider);
+
+            try
+            {
+                var transportTask = transport.RunAsync(cancellationToken: requestAborted);
+                runSession ??= RunSession;
+
+                try
+                {
+                    await runSession(context, server, requestAborted);
+                }
+                finally
+                {
+                    await transport.DisposeAsync();
+                    await transportTask;
+                }
+            }
+            catch (OperationCanceledException) when (requestAborted.IsCancellationRequested)
+            {
+                // RequestAborted always triggers when the client disconnects before a complete response body is written,
+                // but this is how SSE connections are typically closed.
+            }
+            finally
+            {
+                _sessions.TryRemove(sessionId, out _);
+            }
+        });
+
+        routeGroup.MapPost("/message", async context =>
+        {
+            if (!context.Request.Query.TryGetValue("sessionId", out var sessionId))
+            {
+                await Results.BadRequest("Missing sessionId query parameter.").ExecuteAsync(context);
+                return;
+            }
+
+            if (!_sessions.TryGetValue(sessionId.ToString(), out var transport))
+            {
+                await Results.BadRequest($"Session {sessionId} not found.").ExecuteAsync(context);
+                return;
+            }
+
+            var message = await context.Request.ReadFromJsonAsync<IJsonRpcMessage>(McpJsonUtilities.DefaultOptions, context.RequestAborted);
+            if (message is null)
+            {
+                await Results.BadRequest("No message in request body.").ExecuteAsync(context);
+                return;
+            }
+
+            await transport.OnMessageReceivedAsync(message, context.RequestAborted);
+            context.Response.StatusCode = StatusCodes.Status202Accepted;
+            await context.Response.WriteAsync("Accepted");
+        });
+
+        return routeGroup;
+    }
+
+    private static Task RunSession(HttpContext httpContext, IMcpServer session, CancellationToken requestAborted)
+        => session.RunAsync(requestAborted);
+
+    private static string MakeNewSessionId()
+    {
+        // 128 bits
+        Span<byte> buffer = stackalloc byte[16];
+        RandomNumberGenerator.Fill(buffer);
+        return WebEncoders.Base64UrlEncode(buffer);
+    }
+}

src/ModelContextProtocol.AspNetCore/ModelContextProtocol.AspNetCore.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <IsPackable>true</IsPackable>
+    <PackageId>ModelContextProtocol.AspNetCore</PackageId>
+    <Description>ASP.NET Core extensions for the C# Model Context Protocol (MCP) SDK.</Description>
+    <PackageReadmeFile>README.md</PackageReadmeFile>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <FrameworkReference Include="Microsoft.AspNetCore.App" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="README.md" pack="true" PackagePath="\" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\ModelContextProtocol\ModelContextProtocol.csproj" />
+  </ItemGroup>
+
+</Project>

src/ModelContextProtocol.AspNetCore/README.md

@@ -0,0 +1,54 @@
+# ASP.NET Core extensions for the MCP C# SDK
+
+[![NuGet preview version](https://img.shields.io/nuget/vpre/ModelContextProtocol.svg)](https://www.nuget.org/packages/ModelContextProtocol/absoluteLatest)
+
+The official C# SDK for the [Model Context Protocol](https://modelcontextprotocol.io/), enabling .NET applications, services, and libraries to implement and interact with MCP clients and servers. Please visit our [API documentation](https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.html) for more details on available functionality.
+
+> [!NOTE]
+> This project is in preview; breaking changes can be introduced without prior notice.
+
+## About MCP
+
+The Model Context Protocol (MCP) is an open protocol that standardizes how applications provide context to Large Language Models (LLMs). It enables secure integration between LLMs and various data sources and tools.
+
+For more information about MCP:
+
+- [Official Documentation](https://modelcontextprotocol.io/)
+- [Protocol Specification](https://spec.modelcontextprotocol.io/)
+- [GitHub Organization](https://github.com/modelcontextprotocol)
+
+## Installation
+
+To get started, install the package from NuGet
+
+```
+dotnet new web
+dotnet add package ModelContextProtocol.AspNetcore --prerelease
+```
+
+## Getting Started
+
+```csharp
+// Program.cs
+using ModelContextProtocol;
+using ModelContextProtocol.AspNetCore;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.WebHost.ConfigureKestrel(options =>
+{
+    options.ListenLocalhost(3001);
+});
+builder.Services.AddMcpServer().WithToolsFromAssembly();
+var app = builder.Build();
+
+app.MapMcp();
+
+app.Run();
+
+[McpServerToolType]
+public static class EchoTool
+{
+    [McpServerTool, Description("Echoes the message back to the client.")]
+    public static string Echo(string message) => $"hello {message}";
+}
+```

src/ModelContextProtocol/Client/McpClient.cs

@@ -79,10 +79,9 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
         {
             // Connect transport
             _sessionTransport = await _clientTransport.ConnectAsync(cancellationToken).ConfigureAwait(false);
-            InitializeSession(_sessionTransport);
             // We don't want the ConnectAsync token to cancel the session after we've successfully connected.
             // The base class handles cleaning up the session in DisposeAsync without our help.
-            StartSession(fullSessionCancellationToken: CancellationToken.None);
+            StartSession(_sessionTransport, fullSessionCancellationToken: CancellationToken.None);
 
             // Perform initialization sequence
             using var initializationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
@@ -142,13 +141,14 @@ await SendMessageAsync(
     /// <inheritdoc/>
     public override async ValueTask DisposeUnsynchronizedAsync()
     {
-        if (_connectCts is not null)
-        {
-            await _connectCts.CancelAsync().ConfigureAwait(false);
-        }
-
         try
         {
+            if (_connectCts is not null)
+            {
+                await _connectCts.CancelAsync().ConfigureAwait(false);
+                _connectCts.Dispose();
+            }
+
             await base.DisposeUnsynchronizedAsync().ConfigureAwait(false);
         }
         finally
@@ -157,8 +157,6 @@ public override async ValueTask DisposeUnsynchronizedAsync()
             {
                 await _sessionTransport.DisposeAsync().ConfigureAwait(false);
             }
-
-            _connectCts?.Dispose();
         }
     }
 }

src/ModelContextProtocol/Configuration/McpServerBuilderExtensions.cs

@@ -337,7 +337,7 @@ public static IMcpServerBuilder WithStdioServerTransport(this IMcpServerBuilder
         Throw.IfNull(builder);
 
         builder.Services.AddSingleton<ITransport, StdioServerTransport>();
-        builder.Services.AddHostedService<McpServerSingleSessionHostedService>();
+        builder.Services.AddHostedService<StdioMcpServerHostedService>();
 
         builder.Services.AddSingleton(services =>
         {
@@ -350,18 +350,5 @@ public static IMcpServerBuilder WithStdioServerTransport(this IMcpServerBuilder
 
         return builder;
     }
-
-    /// <summary>
-    /// Adds a server transport that uses SSE via a HttpListener for communication.
-    /// </summary>
-    /// <param name="builder">The builder instance.</param>
-    public static IMcpServerBuilder WithHttpListenerSseServerTransport(this IMcpServerBuilder builder)
-    {
-        Throw.IfNull(builder);
-
-        builder.Services.AddSingleton<IServerTransport, HttpListenerSseServerTransport>();
-        builder.Services.AddHostedService<McpServerMultiSessionHostedService>();
-        return builder;
-    }
     #endregion
 }