C# quickstarts (modelcontextprotocol#216)

* Server quickstart docs for C#

* C# client quickstart

Author: aaronpowell

images/quickstart-dotnet-client.png

@@ -1365,6 +1365,184 @@ 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)
+
+## System Requirements
+Before starting, ensure your system meets these requirements:
+- .NET 8.0 or higher
+- Anthropic API key (Claude)
+- Windows, Linux, or MacOS
+
+## Setting up your environment
+
+First, create a new .NET project:
+```bash
+dotnet new console -n QuickstartClient
+cd QuickstartClient
+```
+
+Then, add the required dependencies to your project:
+```bash
+dotnet add package ModelContextProtocol --preview
+dotnet add package Anthropic.SDK
+dotnet add package Microsoft.Extensions.Hosting
+```
+
+## Setting up your API key
+You'll need an Anthropic API key from the [Anthropic Console](https://console.anthropic.com/settings/keys).
+
+```bash
+dotnet user-secrets init
+dotnet user-secrets set "ANTHROPIC_API_KEY" "<your key here>"
+```
+
+## Creating the Client
+### Basic Client Structure
+First, let's setup the basic client class:
+```csharp
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Hosting;
+
+var builder = Host.CreateEmptyApplicationBuilder(settings: null);
+
+builder.Configuration
+    .AddUserSecrets<Program>();
+```
+
+This creates the beginnings of a .NET console application that can read the API key from user secrets.
+
+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 mcpClient = await McpClientFactory.CreateAsync(new()
+{
+    Id = "demo-client",
+    Name = "Demo Client",
+    TransportType = TransportTypes.StdIo,
+    TransportOptions = new()
+    {
+        ["command"] = command,
+        ["arguments"] = arguments,
+    }
+});
+
+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:
+```csharp
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol.Transport;
+```
+</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.
+
+### Query processing logic
+Now let's add the core functionality for processing queries and handling tool calls:
+
+```csharp
+IChatClient anthropicClient = new AnthropicClient(new APIAuthentication(builder.Configuration["ANTHROPIC_API_KEY"]))
+    .Messages
+    .AsBuilder()
+    .UseFunctionInvocation()
+    .Build();
+
+var options = new ChatOptions
+{
+    MaxOutputTokens = 1000,
+    ModelId = "claude-3-5-sonnet-20241022",
+    Tools = [.. tools.Cast<AITool>()]
+};
+
+while (true)
+{
+    Console.WriteLine("MCP Client Started!");
+    Console.WriteLine("Type your queries or 'quit' to exit.");
+
+    string? query = Console.ReadLine();
+
+    if (string.IsNullOrWhiteSpace(query))
+    {
+        continue;
+    }
+    if (string.Equals(query, "quit", StringComparison.OrdinalIgnoreCase))
+    {
+        break;
+    }
+
+    var response = await anthropicClient.GetResponseAsync(query, options);
+
+    foreach (var message in response.Messages)
+    {
+        Console.WriteLine(message.Text);
+    }
+}
+
+anthropicClient.Dispose();
+await mcpClient.DisposeAsync();
+```
+
+## Key Components Explained
+
+### 1. Client Initialization
+* The client is initialized using `McpClientFactory.CreateAsync()`, which sets up the transport type and command to run the server.
+
+### 2. Server Connection
+* Supports Python, Node.js, and .NET servers.
+* The server is started using the command specified in the arguments.
+* Configures to use stdio for communication with the server.
+* Initializes the session and available tools.
+
+### 3. Query Processing
+* Leverages [Microsoft.Extensions.AI](https://learn.microsoft.com/dotnet/ai/ai-extensions) for the chat client.
+* Configures the `IChatClient` to use automatic tool (function) invocation.
+* The client reads user input and sends it to the server.
+* The server processes the query and returns a response.
+* The response is displayed to the user.
+
+### Running the Client
+To run your client with any MCP server:
+```bash
+dotnet run -- path/to/server.csproj # dotnet server
+dotnet run -- path/to/server.py # python server
+dotnet run -- path/to/server.js # node server
+```
+<Note>
+If you're continuing the weather tutorial from the server quickstart, your command might look something like this: `dotnet run -- path/to/QuickstartWeatherServer`.
+</Note>
+
+The client will:
+
+1. Connect to the specified server
+2. List available tools
+3. Start an interactive chat session where you can:
+   - Enter queries
+   - See tool executions
+   - Get responses from Claude
+4. Exit the session when done
+
+Here's an example of what it should look like it connected to a weather server quickstart:
+
+<Frame>
+  <img src="/images/quickstart-dotnet-client.png" />
+</Frame>
+
+</Tab>
+
 </Tabs>
 
 ## Next steps