MCP C# SDK

The Model Context Protocol (MCP) is an open protocol designed to standardize how applications provide context to Large Language Models (LLMs). It facilitates secure integration between LLMs and various data sources and tools.

Developers can use the C# SDK to build implementations that adhere to this protocol, allowing for interoperability between different MCP-compliant clients and servers.

The SDK provides extension points for advanced functionality:

• MCP Apps: Deliver interactive UIs directly from MCP servers.
• Tasks: Use task-based execution for long-running operations that support status polling and result retrieval.
• Identity and Roles: Access caller identity and roles within tool, prompt, and resource handlers.

Servers can expose various capabilities to clients:

• Tools: Implement tools that return text, images, audio, and embedded resources.
• Resources: Expose data via resources, including templates and subscriptions.
• Prompts: Implement reusable prompt templates with rich content types.
• Completions: Provide argument auto-completion for prompts and resource templates.
• Logging: Implement server-side logging that clients can consume.
• Pagination: Use cursor-based pagination when listing tools, prompts, and resources.
• HTTP Context: Access the underlying HttpContext for specific requests.
• MCP Server Handler Filters: Add filters to the handler pipeline to wrap original handlers with custom functionality.

The Model Context Protocol SDK implements several core protocol mechanisms:

• Capabilities: Negotiation of client and server capabilities and protocol versions during initialization.
• Transports: Configuration of communication channels including stdio, Streamable HTTP, and SSE.
• Stateless vs Stateful: Configuration of HTTP server modes and session management.
• Ping: Connection health verification.
• Progress tracking: Monitoring long-running operations via notification messages.
• Cancellation: Using cancellation tokens and notifications to abort in-flight requests.
• Multi Round-Trip Requests (MRTR): Allowing servers to request client input during tool execution via input-required results and retries.

Clients can leverage the following advanced features:

• Sampling: Allows servers to request LLM completions from the client.
• Roots: Provides filesystem roots to servers to enable context-aware operations.
• Elicitation: Enables requesting additional information from users during interactions.

Streamable HTTP uses two distinct channels for message flow between client and server:

1. POST response streams (Solicited messages): Every JSON-RPC request from the client arrives via an HTTP POST. The server holds the response body open as an SSE stream. This stream carries the JSON-RPC response and any messages produced during the execution of that specific handler (e.g., progress notifications, logs, or server-to-client requests like sampling or elicitation).

2. The GET stream (Unsolicited messages): An optional long-lived HTTP GET request used for messages initiated by the server outside of an active request handler (e.g., background resource changes or asynchronous logs).

Warning: If a client does not open a GET stream, the server will silently drop all unsolicited messages.

Deprecation Warning

Sampling is deprecated as of MCP specification revision 2026-07-28 and may be removed in a future version. For stateless-compatible alternatives, use Multi round-trip requests (MRTR) by throwing InputRequiredException.

Overview

Sampling allows an MCP server to request LLM completions from the connected client. This enables agentic behaviors where a tool delegates reasoning (like summarization or decision-making) back to the client's model.

Requirements

• Sampling is a server-to-client request.
• It requires stateful mode or stdio. It is not available in stateless mode.
• The client must advertise the sampling capability (this happens automatically when a SamplingHandler is configured).

Clients can subscribe to resource updates to be notified when content changes. The server must support subscriptions.

You can subscribe with an inline handler that is called when a notification is received, or subscribe without a handler and use a global notification handler.

// Subscribe with an inline handler
IAsyncDisposable subscription = await client.SubscribeToResourceAsync(
    "config://app/settings",
    async (notification, cancellationToken) =>
    {
        Console.WriteLine($"Resource updated: {notification.Uri}");
        var updated = await client.ReadResourceAsync(notification.Uri, cancellationToken: cancellationToken);
    });

// Unsubscribe
await subscription.DisposeAsync();

// Alternative: Subscribe without a handler
await client.SubscribeToResourceAsync("config://app/settings");
await client.UnsubscribeFromResourceAsync("config://app/settings");

To run the end-to-end demonstration of the MCP tasks extension, use the dotnet run command pointing to the sample project. This sample demonstrates a server using an in-memory IMcpTaskStore and a client using CallToolAsTaskAsync with manual polling.

dotnet run --project samples/TasksExtension/TasksExtension.csproj