Address comments in PR review

Author: mikekistler

docs/concepts/elicitation/elicitation.md

@@ -5,9 +5,11 @@ description: Enable interactive AI experiences by requesting user input during t
 uid: elicitation
 ---
 
+## Elicitation
+
 The **elicitation** feature allows servers to request additional information from users during interactions. This enables more dynamic and interactive AI experiences, making it easier to gather necessary context before executing tasks.
 
-## Server Support for Elicitation
+### Server Support for Elicitation
 
 Servers request structured data from users with the [ElicitAsync] extension method on [IMcpServer].
 The C# SDK registers an instance of [IMcpServer] with the dependency injection container,
@@ -27,7 +29,7 @@ The following example demonstrates how a server could request a boolean response
 
 [!code-csharp[](samples/server/Tools/InteractiveTools.cs?name=snippet_GuessTheNumber)]
 
-## Client Support for Elicitation
+### Client Support for Elicitation
 
 Elicitation is an optional feature so clients declare their support for it in their capabilities as part of the `initialize` request. In the MCP C# SDK, this is done by configuring an [ElicitationHandler] in the [McpClientOptions]:
 

docs/concepts/logging/logging.md

@@ -5,6 +5,8 @@ description: How to use the logging feature in the MCP C# SDK.
 uid: logging
 ---
 
+## Logging
+
 MCP servers may expose log messages to clients through the [Logging utility].
 
 [Logging utility]: https://modelcontextprotocol.io/specification/2025-06-18/server/utilities/logging
@@ -43,10 +45,14 @@ MCP servers that implement the Logging utility must declare this in the capabili
 
 [Initialization]: https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle#initialization
 
-Servers built with the C# SDK always declare the logging capability. The C# SDK provides an extension method
-[WithSetLoggingLevelHandler] on [IMcpServerBuilder] to allow the server to perform any special logic it wants to perform
-when a client sets the logging level. However, the SDK already takes care of setting the [LoggingLevel]
-in the [IMcpServer], so most servers will not need to implement this.
+Servers built with the C# SDK always declare the logging capability. Doing so does not obligate the server
+to send log messages -- only allows it. Note that stateless MCP servers may not be capable of sending log
+messages as there may not be an open connection to the client on which the log messages could be sent.
+
+The C# SDK provides an extension method [WithSetLoggingLevelHandler] on [IMcpServerBuilder] to allow the
+server to perform any special logic it wants to perform when a client sets the logging level. However, the
+SDK already takes care of setting the [LoggingLevel] in the [IMcpServer], so most servers will not need to
+implement this.
 
 [IMcpServer]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Server.IMcpServer.html
 [IMcpServerBuilder]: https://modelcontextprotocol.github.io/csharp-sdk/api/Microsoft.Extensions.DependencyInjection.IMcpServerBuilder.html
@@ -64,24 +70,31 @@ and from that can create an [ILogger] instance for logging messages that should
 
 ### Client support for logging
 
-Clients that wish to receive log messages from the server must first check if logging is supported.
-This is done by checking the [Logging] property of the [ServerCapabilities] field of [IMcpClient].
+When the server indicates that it supports logging, clients should configure
+the logging level to specify which messages the server should send to the client.
+
+Clients should check if the server supports logging by checking the [Logging] property of the [ServerCapabilities] field of [IMcpClient].
 
 [IMcpClient]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Client.IMcpClient.html
 [ServerCapabilities]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Client.IMcpClient.html#ModelContextProtocol_Client_IMcpClient_ServerCapabilities
 [Logging]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Protocol.ServerCapabilities.html#ModelContextProtocol_Protocol_ServerCapabilities_Logging
 
 [!code-csharp[](samples/client/Program.cs?name=snippet_LoggingCapabilities)]
 
-If the server supports logging, the client can set the level of log messages it wishes to receive with
-the [SetLoggingLevel] method on [IMcpClient]. The `loggingLevel` specified here is an MCP logging level.
+If the server supports logging, the client should set the level of log messages it wishes to receive with
+the [SetLoggingLevel] method on [IMcpClient]. If the client does not set a logging level, the server might choose
+to send all log messages or none -- this is not specified in the protocol -- so it is important that the client
+sets a logging level to ensure it receives the desired log messages and only those messages.
+
+The `loggingLevel` set by the client is an MCP logging level.
 See the [Logging Levels](#logging-levels) section above for the mapping between MCP and .NET logging levels.
 
 [SetLoggingLevel]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Client.McpClientExtensions.html#ModelContextProtocol_Client_McpClientExtensions_SetLoggingLevel_ModelContextProtocol_Client_IMcpClient_Microsoft_Extensions_Logging_LogLevel_System_Threading_CancellationToken_
 
 [!code-csharp[](samples/client/Program.cs?name=snippet_LoggingLevel)]
 
 Lastly, the client must configure a notification handler for [NotificationMethods.LoggingMessageNotification] notifications.
+The following example simply writes the log messages to the console.
 
 [NotificationMethods.LoggingMessageNotification]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Protocol.NotificationMethods.html#ModelContextProtocol_Protocol_NotificationMethods_LoggingMessageNotification
 

docs/concepts/logging/samples/client/Program.cs

@@ -45,7 +45,7 @@
     }
 }
 
-// </snippet_LoggingHandler>
+// <snippet_LoggingHandler>
 mcpClient.RegisterNotificationHandler(NotificationMethods.LoggingMessageNotification,
     (notification, ct) =>
     {

docs/concepts/logging/samples/server/Tools/LoggingTools.cs

@@ -16,7 +16,7 @@ public static async Task<string> LoggingTool(
         var progressToken = context.Params?.ProgressToken;
         var stepDuration = duration / steps;
 
-        // <sinppet_LoggingConfiguration >
+        // <snippet_LoggingConfiguration >
         ILoggerProvider loggerProvider = context.Server.AsClientLoggerProvider();
         ILogger logger = loggerProvider.CreateLogger("LoggingTools");
         // </snippet_LoggingConfiguration>

docs/concepts/progress/progress.md

@@ -4,11 +4,14 @@ author: mikekistler
 description:
 uid: progress
 ---
+
+## Progress
+
 The Model Context Protocol (MCP) supports [progress tracking] for long-running operations through notification messages.
 
 [progress tracking]: https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/progress
 
-Typically progress tracking is supported by server tools that perform operations that take a significant amount of time to complete, such as data processing or complex calculations.
+Typically progress tracking is supported by server tools that perform operations that take a significant amount of time to complete, such as image generation or complex calculations.
 However, progress tracking is defined in the MCP specification as a general feature that can be implemented for any request that is handled by either a server or a client.
 This project illustrates the common case of a server tool that performs a long-running operation and sends progress updates to the client.
 
@@ -24,7 +27,7 @@ The parameters passed to [sendNotificationAsync] should be an instance of [Progr
 [IMcpServer]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Server.IMcpServer.html
 [ProgressNotificationParams]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.Protocol.ProgressNotificationParams.html
 
-The server should verify that the caller provided a `progressToken` in the request and include it in the call to [sendNotificationAsync]. The following example demonstrates how a server can send a progress notification:
+The server must verify that the caller provided a `progressToken` in the request and include it in the call to [sendNotificationAsync]. The following example demonstrates how a server can send a progress notification:
 
 [!code-csharp[](samples/server/Tools/LongRunningTools.cs?name=snippet_SendProgress)]
 
@@ -54,8 +57,13 @@ mcpClient.RegisterNotificationHandler(NotificationMethods.ProgressNotification,
     }).ConfigureAwait(false);
 ```
 
-The second way is to pass a [Progress<T>] instance to the tool method. The MCP C# SDK will automatically handle progress notifications and report them through the [Progress<T>] instance. This notification handler will only receive progress updates for the specific request that was made, rather than all progress notifications from the server.
+The second way is to pass a [Progress`<T>`] instance to the tool method. [Progress`<T>`] is a standard .NET type that provides a way to receive progress updates.
+For the purposes of MCP progress notifications, `T` should be [ProgressNotificationValue].
+The MCP C# SDK will automatically handle progress notifications and report them through the [Progress`<T>`] instance.
+This notification handler will only receive progress updates for the specific request that was made,
+rather than all progress notifications from the server.
 
-[Progress<T>]: https://learn.microsoft.com/en-us/dotnet/api/system.progress-1
+[Progress`<T>`]: https://learn.microsoft.com/en-us/dotnet/api/system.progress-1
+[ProgressNotificationValue]: https://modelcontextprotocol.github.io/csharp-sdk/api/ModelContextProtocol.ProgressNotificationValue.html
 
 [!code-csharp[](samples/client/Program.cs?name=snippet_ProgressHandler)]

docs/concepts/progress/samples/server/Tools/LongRunningTools.cs

@@ -36,7 +36,7 @@ public static async Task<string> LongRunningTool(
                     },
                 });
             }
-            // </snipped_SendProgress >
+            // </snippet_SendProgress >
         }
 
         return $"Long running tool completed. Duration: {duration} seconds. Steps: {steps}.";