Update instructions for the C# Client Quickstart (modelcontextprotocol#379)

Author: mikekistler

docs/quickstart/client.mdx

@@ -560,13 +560,13 @@ async connectToServer(serverScriptPath: string) {
         ? "python"
         : "python3"
       : process.execPath;
-    
+
     this.transport = new StdioClientTransport({
       command,
       args: [serverScriptPath],
     });
     this.mcp.connect(this.transport);
-    
+
     const toolsResult = await this.mcp.listTools();
     this.tools = toolsResult.tools.map((tool) => {
       return {
@@ -1370,7 +1370,7 @@ If you see:
 </Tab>
 
 <Tab title="C#">
-[You can find the complete code for this tutorial here.](https://github.io/modelcontextprotocol/csharp-sdk/tree/main/samples/QuickstartClient)
+[You can find the complete code for this tutorial here.](https://github.com/modelcontextprotocol/csharp-sdk/tree/main/samples/QuickstartClient)
 
 ## System Requirements
 Before starting, ensure your system meets these requirements:
@@ -1403,14 +1403,19 @@ dotnet user-secrets set "ANTHROPIC_API_KEY" "<your key here>"
 
 ## Creating the Client
 ### Basic Client Structure
-First, let's setup the basic client class:
+First, let's setup the basic client class in the file `Program.cs`:
 ```csharp
+using Anthropic.SDK;
+using Microsoft.Extensions.AI;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Hosting;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol.Transport;
 
-var builder = Host.CreateEmptyApplicationBuilder(settings: null);
+var builder = Host.CreateApplicationBuilder(args);
 
 builder.Configuration
+    .AddEnvironmentVariables()
     .AddUserSecrets<Program>();
 ```
 
@@ -1419,47 +1424,46 @@ This creates the beginnings of a .NET console application that can read the API
 Next, we'll setup the MCP Client:
 
 ```csharp
-var (command, arguments) = args switch
-{
-    [var script] when script.EndsWith(".py") => ("python", script),
-    [var script] when script.EndsWith(".js") => ("node", script),
-    [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", $"run --project {script} --no-build"),
-    _ => throw new NotSupportedException("An unsupported server script was provided. Supported scripts are .py, .js, or .csproj")
-};
+var (command, arguments) = GetCommandAndArguments(args);
 
-await using var mcpClient = await McpClientFactory.CreateAsync(new()
+var clientTransport = new StdioClientTransport(new()
 {
-    Id = "demo-server",
     Name = "Demo Server",
-    TransportType = TransportTypes.StdIo,
-    TransportOptions = new()
-    {
-        ["command"] = command,
-        ["arguments"] = arguments,
-    }
+    Command = command,
+    Arguments = arguments,
 });
 
+await using var mcpClient = await McpClientFactory.CreateAsync(clientTransport);
+
 var tools = await mcpClient.ListToolsAsync();
 foreach (var tool in tools)
 {
     Console.WriteLine($"Connected to server with tools: {tool.Name}");
 }
 ```
-<Note>
-Be sure to add the `using` statements for the namespaces:
+
+Add this function at the end of the `Program.cs` file:
+
 ```csharp
-using ModelContextProtocol.Client;
-using ModelContextProtocol.Protocol.Transport;
+static (string command, string[] arguments) GetCommandAndArguments(string[] args)
+{
+    return args switch
+    {
+        [var script] when script.EndsWith(".py") => ("python", args),
+        [var script] when script.EndsWith(".js") => ("node", args),
+        [var script] when Directory.Exists(script) || (File.Exists(script) && script.EndsWith(".csproj")) => ("dotnet", ["run", "--project", script, "--no-build"]),
+        _ => throw new NotSupportedException("An unsupported server script was provided. Supported scripts are .py, .js, or .csproj")
+    };
+}
 ```
-</Note>
 
-This configures a MCP client that will connect to a server that is provided as a command line argument. It then lists the available tools from the connected server.
+This creates a MCP client that will connect to a server that is provided as a command line argument. It then lists the available tools from the connected server.
 
 ### Query processing logic
 Now let's add the core functionality for processing queries and handling tool calls:
 
 ```csharp
-using IChatClient anthropicClient = new AnthropicClient(new APIAuthentication(builder.Configuration["ANTHROPIC_API_KEY"]))
+using var anthropicClient = new AnthropicClient(new APIAuthentication(builder.Configuration["ANTHROPIC_API_KEY"]))
     .Messages
     .AsBuilder()
     .UseFunctionInvocation()
@@ -1472,29 +1476,34 @@ var options = new ChatOptions
     Tools = [.. tools]
 };
 
-while (true)
-{
-    Console.WriteLine("MCP Client Started!");
-    Console.WriteLine("Type your queries or 'quit' to exit.");
-
-    string? query = Console.ReadLine();
+Console.ForegroundColor = ConsoleColor.Green;
+Console.WriteLine("MCP Client Started!");
+Console.ResetColor();
 
+PromptForInput();
+while(Console.ReadLine() is string query && !"exit".Equals(query, StringComparison.OrdinalIgnoreCase))
+{
     if (string.IsNullOrWhiteSpace(query))
     {
+        PromptForInput();
         continue;
     }
-    if (string.Equals(query, "quit", StringComparison.OrdinalIgnoreCase))
-    {
-        break;
-    }
 
-    var response = anthropicClient.GetStreamingResponseAsync(query, options);
-
-    await foreach (var message in response)
+    await foreach (var message in anthropicClient.GetStreamingResponseAsync(query, options))
     {
-        Console.Write(message.Text);
+        Console.Write(message);
     }
     Console.WriteLine();
+
+    PromptForInput();
+}
+
+static void PromptForInput()
+{
+    Console.WriteLine("Enter a command (or 'exit' to quit):");
+    Console.ForegroundColor = ConsoleColor.Cyan;
+    Console.Write("> ");
+    Console.ResetColor();
 }
 ```
 
@@ -1516,7 +1525,8 @@ while (true)
 * The server processes the query and returns a response.
 * The response is displayed to the user.
 
-### Running the Client
+## Running the Client
+
 To run your client with any MCP server:
 ```bash
 dotnet run -- path/to/server.csproj # dotnet server