github/awesome-copilot / skills/dotnet-mcp-builder
dotnet-mcp-builder
VerifiedBuild Model Context Protocol (MCP) servers in C#/.NET against the current ModelContextProtocol 2.x NuGet packages. Helps with cases the model gets wrong without guidance — stale versions (0.x preview or 1.x-era defaults), the v2 stateless-by-default HTTP flip, the 2026-07-28 spec deprecations (roots/sampling/logging), MCP Apps and Tasks extension packages, elicitation URL mode, per-session HTTP wiring, OAuth and reverse-proxy deploy specifics, and debugging MapMcp / STDIO / Streamable-HTTP errors. Also covers STDIO and Streamable HTTP transports (SSE is deprecated), tools, prompts, resources, completions, and a basic .NET MCP client. Trigger when the user says or implies any .NET MCP server work: ModelContextProtocol, McpServerTool, MapMcp, WithStdioServerTransport, "MCP server in C#", "MCP tool in dotnet", "expose this as MCP", or names a primitive (prompt/resource/elicitation/MCP App) in a .NET context. Skip for MCP work in other languages.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.4 KB |
| references/client.md | markdown | 6.2 KB |
| references/elicitation.md | markdown | 7.8 KB |
| references/mcp-apps.md | markdown | 9.8 KB |
| references/packages.md | markdown | 5.2 KB |
| references/prompt-primitive.md | markdown | 5.0 KB |
| references/resource-primitive.md | markdown | 6.1 KB |
| references/roots.md | markdown | 4.0 KB |
| references/sampling.md | markdown | 5.4 KB |
| references/server-features.md | markdown | 6.6 KB |
| references/testing.md | markdown | 6.1 KB |
| references/tool-primitive.md | markdown | 8.4 KB |
| references/transport-http.md | markdown | 8.4 KB |
| references/transport-stdio.md | markdown | 5.1 KB |
references/server-features.md
View on GitHub# Other server features (completions, logging, progress, filters)
A quick reference for the smaller MCP server features beyond the core primitives. Each section is short — load this file when one of these comes up.
## Argument completions
Completions let the host autocomplete prompt arguments and resource template parameters. The user starts typing; the client asks the server "what are valid values?".
Implement via the low-level handler (no high-level attribute exists yet):
```csharp
builder.Services.Configure<McpServerOptions>(options =>
{
options.Capabilities ??= new();
options.Capabilities.Completions ??= new();
options.Capabilities.Completions.CompleteHandler = async (ctx, ct) =>
{
// ctx.Params.Ref tells us what they're completing (a prompt or resource).
// ctx.Params.Argument has the partial value typed so far.
var partial = ctx.Params.Argument.Value ?? "";
var matches = MyDataSource
.Where(x => x.StartsWith(partial, StringComparison.OrdinalIgnoreCase))
.Take(100)
.ToArray();
return new CompleteResult
{
Completion = new()
{
Values = matches,
HasMore = false,
Total = matches.Length
}
};
};
});
```
Useful for: project IDs, file names, enum values that depend on dynamic data.
## Logging
Servers can emit log messages that hosts surface in their UI (and the LLM can sometimes see). Use the standard `ILogger<T>` injected via DI — the SDK plumbs it through.
```csharp
public class WeatherTools
{
private readonly ILogger<WeatherTools> _log;
public WeatherTools(ILogger<WeatherTools> log) => _log = log;
[McpServerTool, Description("…")]
public string GetWeather(string city)
{
_log.LogInformation("Looking up weather for {City}", city);
return "...";
}
}
```
For STDIO servers, remember: console logging **must** go to stderr (`LogToStandardErrorThreshold = LogLevel.Trace`) — otherwise it corrupts the JSON-RPC stream. See [`transport-stdio.md`](./transport-stdio.md).
> **MCP-channel logging is deprecated in the 2026-07-28 spec** — SDK 2.x marks it `[Obsolete]` (`MCP9005`), along with the `logging` capability and the client's `setLevel` method (replaced by a `_meta` log level on requests). `ILogger`-based logging above is unaffected and remains the right default. Only use the MCP-channel notification below when supporting down-level clients that expect it:
```csharp
await server.SendNotificationAsync(
NotificationMethods.LoggingMessageNotification,
new LoggingMessageNotificationParams
{
Level = LoggingLevel.Info,
Logger = "weather",
Data = JsonSerializer.SerializeToElement(new { city, latency_ms = 123 })
},
ct);
```
The client may have set a `setLevel` filter — don't spam levels below it.
## Progress notifications
For long-running tools, send progress updates so the host can display a spinner with text:
```csharp
[McpServerTool, Description("Processes a large dataset.")]
public static async Task<string> Process(
IMcpServer server,
RequestContext<CallToolRequestParams> ctx,
string datasetId,
CancellationToken ct)
{
var progressToken = ctx.Params.Meta?.ProgressToken;
for (int i = 0; i < 100; i++)
{
await Task.Delay(50, ct);
if (progressToken is not null)
{
await server.SendNotificationAsync(
NotificationMethods.ProgressNotification,
new ProgressNotificationParams
{
ProgressToken = progressToken,
Progress = i + 1,
Total = 100,
Message = $"Processing item {i + 1} of 100"
},
ct);
}
}
return "Done.";
}
```
Only send progress if the client passed a `progressToken` in the request meta — otherwise the host isn't listening.
## Notification handlers (server-side)
Servers can react to notifications the client sends:
```csharp
options.Capabilities ??= new();
options.Capabilities.NotificationHandlers ??= [];
options.Capabilities.NotificationHandlers[NotificationMethods.RootsListChangedNotification] =
async (notification, ct) =>
{
// Refresh root cache, etc.
};
options.Capabilities.NotificationHandlers[NotificationMethods.CancelledNotification] =
async (notification, ct) =>
{
// The client cancelled a request; if you have side-effects in flight, abort them.
};
```
## Filters / middleware
The SDK supports filters that wrap tool calls (think ASP.NET Core middleware for MCP). Use them for cross-cutting concerns: auth checks, telemetry, rate limiting, audit logging.
```csharp
builder.Services
.AddMcpServer()
.WithStdioServerTransport()
.WithToolsFromAssembly()
.WithCallToolFilter(async (ctx, next) =>
{
var sw = Stopwatch.StartNew();
try
{
return await next(ctx);
}
finally
{
sw.Stop();
ctx.Server.Services?
.GetRequiredService<ILogger<Program>>()
.LogInformation("Tool {Tool} took {Ms}ms",
ctx.Params.Name, sw.ElapsedMilliseconds);
}
});
```
Similar `With*Filter` helpers exist for resources, prompts, and other capabilities — check the SDK API reference for the current set.
## Server instructions (system-prompt-ish)
You can supply instructions sent to the client at initialise time. Hosts may include them in the LLM's system prompt.
```csharp
builder.Services.AddMcpServer(options =>
{
options.ServerInstructions =
"Use the booking tools to schedule meetings. " +
"Always confirm with the user before booking via elicitation.";
});
```
Keep this short — every token here costs the user.
## Capabilities advertising
If you want to *not* advertise a capability you happen to have code for, you can mute it:
```csharp
builder.Services.AddMcpServer(options =>
{
options.Capabilities = new()
{
Tools = new(), // advertise tools
Prompts = new(), // advertise prompts
Resources = null, // do NOT advertise resources, even if some are registered
};
});
```
By default, the SDK advertises everything you've registered — usually the right behaviour. Note that `Logging` is `[Obsolete]` in 2.x (`MCP9005`) — don't advertise it on new servers. Roots and sampling are *client* capabilities: a server never advertises them, it only checks `server.ClientCapabilities?.Roots` / `.Sampling` before using the (equally deprecated) client-side features.
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| writing-skillsobra/superpowersUse when creating new skills, editing existing skills, or verifying skills work before deployment | Stars: 321k | Updated | Claude CodeCodex | Verified | Install |
| xlsxanthropics/skillsUse this skill any time a spreadsheet file is the primary input or output. This means any task where the user wants to: open, read, edit, or fix an existing .xlsx, .xlsm, .xltx, .csv, or .tsv file (e.g., adding columns, computing formulas, formatting, charting, cleaning messy data); create a new spreadsheet from scratch or from other data sources; or convert between tabular file formats. Trigger especially when the user references a spreadsheet file by name or path — even casually (like "the xlsx in my downloads") — and wants something done to it or produced from it. Also trigger for cleaning or restructuring messy tabular data files (malformed rows, misplaced headers, junk data) into proper spreadsheets. The deliverable must be a spreadsheet file. Do NOT trigger when the primary deliverable is a Word document, HTML report, standalone Python script, database pipeline, or Google Sheets API integration, even if tabular data is involved. | Stars: 197k | Updated | Claude CodeCodex | Verified | Install |
| shipping-and-launchaddyosmani/agent-skillsPrepares production launches. Use when preparing to deploy to production, or when asking what needs to be in place before shipping. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy. | Stars: 119k | Updated | Claude CodeCodex | Verified | Install |
| childhoodthedotmack/claude-memBabysit a shipped release after merge, publication, or deployment. Verify published packages, production behavior, installed plugins, and late CI or user reports until the observation window is clean; use babysit for PR readiness before release. | Stars: 118k | Updated | Claude CodeCodex | Verified | Install |