Update all Server comments

Author: stephentoub

src/ModelContextProtocol.AspNetCore/McpEndpointRouteBuilderExtensions.cs

@@ -18,7 +18,7 @@
 namespace Microsoft.AspNetCore.Builder;
 
 /// <summary>
-/// Extension methods for <see cref="IEndpointRouteBuilder"/> to add MCP endpoints.
+/// Provides extension methods for <see cref="IEndpointRouteBuilder"/> to add MCP endpoints.
 /// </summary>
 public static class McpEndpointRouteBuilderExtensions
 {

src/ModelContextProtocol/Client/IMcpClient.cs

@@ -5,20 +5,6 @@ namespace ModelContextProtocol.Client;
 /// <summary>
 /// Represents an instance of a Model Context Protocol (MCP) client that connects to and communicates with an MCP server.
 /// </summary>
-/// <remarks>
-/// <para>
-/// The MCP client provides a standardized way to interact with AI tool servers, allowing applications to:
-/// <list type="bullet">
-///   <item>Connect to MCP-compliant servers</item>
-///   <item>Discover and use available tools, prompts, and resources</item>
-///   <item>Execute tool calls and prompt completions</item>
-///   <item>Subscribe to and receive notifications from resources</item>
-/// </list>
-/// </para>
-/// <para>
-/// An <see cref="IMcpClient"/> instance is typically created using <see cref="McpClientFactory"/> and should be disposed of properly when finished.
-/// </para>
-/// </remarks>
 public interface IMcpClient : IMcpEndpoint
 {
     /// <summary>

src/ModelContextProtocol/Server/IMcpServer.cs

@@ -3,52 +3,8 @@
 namespace ModelContextProtocol.Server;
 
 /// <summary>
-/// Represents a server that can communicate with a client using the Model Context Protocol (MCP).
+/// Represents an instance of a Model Context Protocol (MCP) server that connects to and communicates with an MCP client.
 /// </summary>
-/// <remarks>
-/// <para>
-/// The IMcpServer interface provides core functionality for handling client requests,
-/// managing capabilities, and enabling bidirectional communication using the MCP protocol.
-/// </para>
-/// <para>
-/// Servers can be created using <see cref="McpServerFactory"/> or configured via dependency injection
-/// with <see cref="Microsoft.Extensions.DependencyInjection.IMcpServerBuilder"/>.
-/// </para>
-/// <para>
-/// Example usage in a basic console application:
-/// <code>
-/// // Create transport and options
-/// var transport = new StdioTransport();
-/// var options = new McpServerOptions
-/// {
-///     ServerCapabilities = new()
-///     {
-///         ToolsCollection = new()
-///         {
-///             McpServerTool.Create((string message) => $"Echo: {message}", 
-///                 new() { Name = "Echo", Description = "Echoes a message back to the client." })
-///         }
-///     }
-/// };
-/// 
-/// // Create and run the server
-/// await using var server = McpServerFactory.Create(transport, options);
-/// await server.RunAsync();
-/// </code>
-/// </para>
-/// <para>
-/// Example usage in a background service:
-/// <code>
-/// public class MyBackgroundService(IMcpServer server) : BackgroundService
-/// {
-///     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
-///     {
-///         await server.RunAsync(stoppingToken);
-///     }
-/// }
-/// </code>
-/// </para>
-/// </remarks>
 public interface IMcpServer : IMcpEndpoint
 {
     /// <summary>
@@ -64,15 +20,6 @@ public interface IMcpServer : IMcpEndpoint
     /// Server implementations can check these capabilities to determine which features
     /// are available when interacting with the client.
     /// </para>
-    /// <para>
-    /// Example checking for sampling capability:
-    /// <code>
-    /// if (server.ClientCapabilities?.Sampling != null)
-    /// {
-    ///     // Client supports sampling capabilities
-    /// }
-    /// </code>
-    /// </para>
     /// </remarks>
     ClientCapabilities? ClientCapabilities { get; }
 
@@ -88,34 +35,15 @@ public interface IMcpServer : IMcpEndpoint
     /// Server implementations can use this information for logging, tracking client versions, 
     /// or implementing client-specific behaviors.
     /// </para>
-    /// <para>
-    /// Example usage:
-    /// <code>
-    /// if (server.ClientInfo != null)
-    /// {
-    ///     logger.LogInformation($"Connected to {server.ClientInfo.Name} version {server.ClientInfo.Version}");
-    /// }
-    /// </code>
-    /// </para>
     /// </remarks>
     Implementation? ClientInfo { get; }
 
     /// <summary>
     /// Gets the options used to construct this server.
     /// </summary>
     /// <remarks>
-    /// <para>
     /// These options define the server's capabilities, protocol version, and other configuration
-    /// settings that were used to initialize the server. They represent the negotiated settings
-    /// that are active for the current server session.
-    /// </para>
-    /// <para>
-    /// Example of accessing server options:
-    /// <code>
-    /// var protocolVersion = server.ServerOptions.ProtocolVersion;
-    /// var supportsTools = server.ServerOptions.Capabilities?.Tools != null;
-    /// </code>
-    /// </para>
+    /// settings that were used to initialize the server.
     /// </remarks>
     McpServerOptions ServerOptions { get; }
 

src/ModelContextProtocol/Server/IMcpServerPrimitive.cs

@@ -3,38 +3,6 @@ namespace ModelContextProtocol.Server;
 /// <summary>
 /// Represents an MCP server primitive, like a tool or a prompt.
 /// </summary>
-/// <remarks>
-/// <para>
-/// MCP server primitives are the building blocks of MCP servers, providing functionality
-/// that can be exposed to clients. The two main types of primitives are tools (which perform actions)
-/// and prompts (which provide pre-defined text templates).
-/// </para>
-/// <para>
-/// In the Model Context Protocol architecture, primitives are fundamental components that 
-/// enable communication between AI models and applications. They provide a standardized way 
-/// to expose functionality that models can utilize during inference, allowing for dynamic 
-/// interactions between the model and external systems.
-/// </para>
-/// <para>
-/// IMcpServerPrimitive is implemented by <see cref="McpServerTool"/> and <see cref="McpServerPrompt"/>,
-/// which provide concrete implementations for tools and prompts respectively. These primitives
-/// are registered with the MCP server and made available to client applications.
-/// </para>
-/// <para>
-/// Example primitive implementations can be found in the samples, such as:
-/// <code>
-/// [McpServerToolType]
-/// public class MyTools
-/// {
-///     [McpServerTool(Name = "echo")]
-///     public static string Echo(IMcpServer server, string message)
-///     {
-///         return $"Echo: {message}";
-///     }
-/// }
-/// </code>
-/// </para>
-/// </remarks>
 public interface IMcpServerPrimitive
 {
     /// <summary>Gets the name of the primitive.</summary>

src/ModelContextProtocol/Server/McpServer.cs

@@ -39,13 +39,9 @@ internal sealed class McpServer : McpEndpoint, IMcpServer
     /// <param name="transport">Transport to use for the server representing an already-established session.</param>
     /// <param name="options">Configuration options for this server, including capabilities.
     /// Make sure to accurately reflect exactly what capabilities the server supports and does not support.</param>
-    /// <param name="loggerFactory">Logger factory to use for logging. Provides logging capabilities to the server
-    /// for diagnostic and troubleshooting purposes. If null, a NullLogger will be used with no output.</param>
+    /// <param name="loggerFactory">Logger factory to use for logging</param>
     /// <param name="serviceProvider">Optional service provider to use for dependency injection</param>
     /// <exception cref="McpException">The server was incorrectly configured.</exception>
-    /// <remarks>
-    /// This constructor is internal. Use <see cref="McpServerFactory.Create"/> to create a server instance.
-    /// </remarks>
     public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory? loggerFactory, IServiceProvider? serviceProvider)
         : base(loggerFactory)
     {
@@ -99,22 +95,6 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
         InitializeSession(transport);
     }
 
-    /// <summary>
-    /// Gets or sets the capabilities supported by this server.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// These capabilities are advertised to the client during the initialize handshake.
-    /// </para>
-    /// <para>
-    /// The server capabilities define what features the server supports, such as tools,
-    /// prompts, resources, logging, completions, and other protocol-specific functionality.
-    /// </para>
-    /// <para>
-    /// This property is typically set during server initialization based on the
-    /// configured <see cref="McpServerOptions.Capabilities"/>.
-    /// </para>
-    /// </remarks>
     public ServerCapabilities? ServerCapabilities { get; set; }
 
     /// <inheritdoc />
@@ -130,17 +110,6 @@ public McpServer(ITransport transport, McpServerOptions options, ILoggerFactory?
     public IServiceProvider? Services { get; }
 
     /// <inheritdoc />
-    /// <inheritdoc/>
-    /// <remarks>
-    /// <para>
-    /// For servers, the endpoint name is formatted as "Server ({ServerInfo.Name} {ServerInfo.Version})".
-    /// </para>
-    /// <para>
-    /// This property returns the internal <see cref="_endpointName"/> field, which is initialized during construction
-    /// and may be updated if client information becomes available during the session.
-    /// It's used in all logging operations to identify this specific server endpoint.
-    /// </para>
-    /// </remarks>
     public override string EndpointName => _endpointName;
 
     /// <inheritdoc />
@@ -165,18 +134,6 @@ public async Task RunAsync(CancellationToken cancellationToken = default)
         }
     }
 
-    /// <inheritdoc/>
-    /// <summary>
-    /// Asynchronously releases resources used by the MCP server without any synchronization.
-    /// </summary>
-    /// <returns>A task that represents the asynchronous dispose operation.</returns>
-    /// <remarks>
-    /// This method:
-    /// <list type="bullet">
-    /// <item><description>Unregisters tool and prompt collection change event handlers</description></item>
-    /// <item><description>Calls the base class implementation to clean up common endpoint resources</description></item>
-    /// </list>
-    /// </remarks>
     public override async ValueTask DisposeUnsynchronizedAsync()
     {
         if (_toolsChangedDelegate is not null &&
@@ -233,7 +190,7 @@ private void SetCompletionHandler(McpServerOptions options)
             return;
         }
 
-        var completeHandler = completionsCapability.CompleteHandler ?? 
+        var completeHandler = completionsCapability.CompleteHandler ??
             throw new McpException("Completions capability was enabled, but Complete handler was not specified.");
 
         // This capability is not optional, so return an empty result if there is no handler.