Meu servidor MCP em C# respondeu 200 pra quem não mandou credencial nenhuma, e as definições que o tools/list dele entrega custam 223 tokens por pedido. Usei o SDK oficial 2.4.0 e as mesmas 4 ferramentas da demo 13. É o mesmo custo da definição escrita à mão, contra 275 do servidor em Python. Isso o SDK resolveu bem. O resto que eu medi veio aberto: sem header nenhum, com token inventado e com Origin de outro site, a resposta foi 200 nos três casos. Uma rajada de 500 chamadas passou inteira, com 0 respostas 429.
O código está no repositório: demos/16-mcp-servidor-csharp. Roda em CPU, sem conta e sem chave.
Por que medir o lado do servidor?
No artigo de 10/11/2026 eu medi o lado de quem usa: quanto contexto a mesma ferramenta ocupa como MCP, como função de API e como Skill. O MCP em Python saiu 52 tokens mais caro que a definição à mão, por causa de campos title que o Pydantic põe no JSON Schema.
Ficou a pergunta do outro lado. Se eu sou o dev .NET que vai expor ferramentas pra um agente, o que o SDK me entrega pronto e o que eu escrevo na mão?
Qual é o recurso?
O SDK C# do Model Context Protocol, mantido no projeto oficial do MCP. Usei o pacote ModelContextProtocol.AspNetCore 2.4.0, publicado no NuGet em 07/11/2026, licença Apache-2.0. Ele traz o transporte HTTP do MCP pra dentro do ASP.NET Core. Rodei no .NET 8 (SDK 8.0.134).
O servidor inteiro é isto:
var builder = WebApplication.CreateBuilder(args);
builder.Services
.AddMcpServer()
.WithHttpTransport()
.WithToolsFromAssembly();
var app = builder.Build();
app.MapMcp("/mcp");
app.Run(args.Length > 0 ? args[0] : "http://127.0.0.1:5088");
E cada ferramenta é um método com dois atributos:
[McpServerTool(Name = "mascarar_identificadores")]
[Description("Troca CPF e CNS válidos do texto por [CPF] e [CNS]. Número inválido fica como está.")]
public static string MascararIdentificadores(string texto)
{
texto = Cns.Replace(texto, m => ValidarCns(m.Value) ? "[CNS]" : m.Value);
return Cpf.Replace(texto, m => ValidarCpf(m.Value) ? "[CPF]" : m.Value);
}
Mesmos nomes e mesmas descrições da demo 13: validar CPF, validar CNS, mascarar e contar identificadores. Dado sintético, com CPF e CNS gerados por algoritmo e o paciente “FULANO DE TAL SINTETICO”.
Como eu rodei?
Não usei SDK de cliente. Um script em Python sobe o servidor, fala JSON-RPC cru com ele por HTTP e anota o que volta. Assim dá pra ver exatamente o que trafega no fio. O script mede cinco coisas:
- os tokens das definições que o host repassa pro modelo (nome, descrição e
inputSchema), com o tiktokeno200k_base, igual à demo 13; - o tempo de 200 chamadas em sequência, com o servidor quente;
- três clientes diferentes: sem header nenhum, com
Authorization: Bearer token-inventado-123e comOrigin: http://site-qualquer.example; - uma rajada de 500 chamadas, 20 clientes em paralelo;
- o que o log padrão do ASP.NET Core registrou.
Do processo subir até a primeira resposta: 450 ms.
Quanto as 4 ferramentas ocupam?
| o que vai pro modelo | o200k_base | cl100k_base |
|---|---|---|
| servidor C#, SDK 2.4.0 | 223 | 231 |
servidor Python, mcp 2.3.0 (demo 13) |
275 | 283 |
Python sem os campos title |
223 | 231 |
resposta inteira do tools/list em C# |
225 | 232 |
O C# não gera title nenhum no schema. Foram 0 campos, contra 14 no Python. O schema de entrada sai seco:
{"type":"object","properties":{"cpf":{"type":"string"}},"required":["cpf"]}
O C# também não mandou outputSchema em nenhuma das 4. A saída do mascarar_identificadores bateu letra por letra com a da demo 13.
Uma chamada de ferramenta levou 1,83 ms de mediana, p95 de 2,26 ms, na mesma máquina. É ida e volta medida pelo cliente Python, no loopback, sem rede e sem modelo no meio.
O que acontece sem autenticação?
| cliente | initialize | tools/call | devolveu o texto? |
|---|---|---|---|
| sem header nenhum | 200 | 200 | sim |
| token inventado | 200 | 200 | sim |
Origin de outro site |
200 | 200 | sim |
| rajada de 500 chamadas | 500 com 200, 0 com 429, em 1,16 s | não conferido | |
Nada disso é bug. O servidor fez o que eu escrevi, e eu não escrevi autenticação. Ele sobe e atende sem ela, e nas 80 primeiras linhas do log não tem nenhum aviso (warn).
O Origin me chamou mais atenção. A spec do transporte HTTP (versão 2025-06-18) diz que o servidor MUST validar o Origin de toda conexão, pra evitar DNS rebinding. É o ataque em que uma página aberta no seu navegador consegue falar com um serviço que roda no seu localhost. Com a configuração padrão, o pedido com Origin de fora passou. Procurei uma opção pra isso na documentação XML do pacote 2.4.0 e não achei. Fica com um middleware seu.
Quais são as 4 coisas que ficam com você?
- Autenticação. O pacote traz o
McpAuthenticationHandler, que publica os metadados de recurso protegido do OAuth, e oAddAuthorizationFilters(), que deixa você marcar ferramenta com[Authorize]. Emitir e validar o token é com o seu servidor de autorização e oAddAuthenticationdo ASP.NET Core. - Validação do
Origin. Um middleware que recusa o que não vem da origem esperada. - Limite de chamadas. O ASP.NET Core tem
AddRateLimiter. O SDK não liga nada: 500 de 500 passaram. - Log de auditoria. O log padrão escreveu 10.702 linhas e citou o nome da ferramenta em 725 linhas. A linha diz
"mascarar_identificadores" completed. IsError = False.; a seguinte dá o tempo dotools/call, sem o nome da ferramenta. Nenhuma das duas diz quem pediu nem com que argumento. Quem chamou só aparece noinitialize, pelo nome que o próprio cliente declarou.
No log tem um lado bom: no nível Information, o padrão, o CPF da nota não apareceu em linha nenhuma. Em Trace, a documentação do SDK diz que ele registra a mensagem JSON-RPC, então cuidado ao ligar. Pra auditoria, o caminho é um filtro (WithRequestFilters(f => f.AddCallToolFilter(...))) que grave identidade, ferramenta, decisão e um hash do argumento. Nunca o dado em claro.
O que não funcionou de primeira?
O primeiro build quebrou. Escrevi a classe de ferramentas como static e registrei com .WithTools<Identificadores>(). O compilador recusou: tipo estático não entra como argumento genérico (CS0718). Troquei por .WithToolsFromAssembly(), que acha sozinho as classes marcadas com [McpServerToolType]. Compilou sem aviso (results/build.txt).
Confesso que eu esperava que a parte chata fosse o schema, porque foi no Python. No C# o schema foi a parte que veio melhor.
Pra quem serve e quando é exagero?
Serve pra quem já tem uma API ou serviço em .NET e quer que um agente, no Claude Code, no Copilot ou num host seu, chame aquilo por MCP. É um Program.cs curto e dois atributos por método. O schema sai enxuto, sem você brigar com serializador. Na minha humilde opinião, essa é a parte boa: 52 tokens a menos por pedido do que o Python, sem fazer nada.
O tempo de implementar vai nas quatro peças acima. OAuth com servidor de autorização, política por ferramenta, limite e log de auditoria exigem alguém no time que conheça ASP.NET Core além do MCP. Se a ferramenta toca dado pessoal, como CPF de paciente, a LGPD (art. 46) pede medidas de segurança, e na minha leitura essas quatro peças entram aí.
Quando não usar:
- Uma ferramenta só e um cliente só. Uma função de API na sua própria aplicação resolve, com o mesmo custo de contexto, e você não abre porta HTTP nenhuma.
- Uso só local, na sua máquina. O transporte stdio não abre porta; a pergunta de autenticação vira “quem pode iniciar o processo”.
- Equipe sem tempo pra fazer as quatro peças. Servidor MCP por HTTP sem elas, fora do
127.0.0.1, é um endpoint aberto.
Até onde esse teste vai?
- O tiktoken não é o tokenizador do Claude. Os números servem pra comparar C# e Python entre si.
- O host pode reescrever a definição. A demo mede o que o servidor manda, não o que cada cliente repassa.
- 4 ferramentas pequenas, parâmetro
stringe sem descrição por parâmetro. Com tipos complexos o schema muda nos dois SDKs. - Não liguei o servidor a um agente de verdade. Falei com ele por JSON-RPC cru.
- Só o transporte HTTP. O stdio fica pra outra rodada.
- SDK em evolução: a 2.4.0 saiu em 07/11/2026. Padrão de log, schema e segurança pode mudar na próxima.
Fonte e como reproduzir
SDK C# do MCP: github.com/modelcontextprotocol/csharp-sdk e ModelContextProtocol.AspNetCore 2.4.0 no NuGet. Spec do transporte: modelcontextprotocol.io/specification/2025-06-18/basic/transports.
Código e saída real: demos/16-mcp-servidor-csharp. Precisa do .NET 8 SDK, de Python 3.11 e do repositório inteiro clonado, porque a comparação lê a demo 13. Três comandos:
cd nursia-research-lab/demos/16-mcp-servidor-csharp && dotnet build -c Release src
pip install -r requirements.txt
python3 demo.py && python3 -m pytest tests -q -s
O teste confere que o C# tem 0 campos title, que a contagem bate com o tools_list.json gravado, que os três clientes sem credencial válida receberam 200 e que a rajada teve 0 respostas 429. A saída fica em results/saida.txt e results/resultado.json.
Dessas quatro peças, qual vocês já tiveram que fazer na mão num servidor de vocês?
English summary
I served the same 4 tools as my 10 Nov 2026 demo from a C# MCP server built with the official SDK (ModelContextProtocol.AspNetCore 2.4.0, .NET 8, HTTP on 127.0.0.1) and measured it with raw JSON-RPC. The tool definitions from tools/list cost 223 tokens per request, the same as hand-written definitions and 52 fewer than the Python SDK, because the C# schema has no title fields. Out of the box there was no auth (no header, a made-up token and a foreign Origin all got 200), no rate limit (500/500 calls, 0 HTTP 429) and no audit trail in the default log. Code: demos/16-mcp-servidor-csharp.
Publicado em 20/11/2026. Changelog: 20/11/2026, publicação. A demo faz parte do nursia-research-lab, repositório de pesquisa do PPGINFOS/UFSC com bolsa FAPESC.

