@polymorphism-tech/morph-spec 8.32.0 → 8.34.2

package/framework/standards/ai-agents/mcp-server.md

@@ -1,250 +1,250 @@
-# MCP Server — Exposing project capabilities as MCP
-
-> **Scope:** stacks=["dotnet"]
-> **Layer:** 2 (on-keyword)
-> **Keywords:** mcp server, expose mcp, build mcp server, mcp host, publish tools, McpServerTool, AddMcpServer
-> **Read by Claude in:** implement (quando um projeto expõe capacidades como MCP server para consumo externo)
-
-**Verified against:** MAF 1.0 GA + ModelContextProtocol C# SDK server-side (`[McpServerToolType]`/`[McpServerTool]`, `WithStdioServerTransport`/`WithHttpTransport`, `ModelContextProtocol.AspNetCore`). Last-verified: 2026-05-19.
-
----
-
-## Quando criar um MCP server
-
-Crie um MCP server quando você quer **expor capacidades do projeto** de forma padronizada para **agentes ou ferramentas externas** consumirem. O protocolo MCP garante interoperabilidade: qualquer agente compatível (Claude Code, outro agent MAF, VS Code Copilot, etc.) pode descobrir e usar as tools do servidor.
-
-**Crie um MCP server quando:**
-
-- Claude Code (ou outro agente externo) precisa executar queries/ações neste projeto
-- Outro projeto MAF precisa consumir lógica encapsulada aqui via protocolo padrão
-- Você quer expor capacidades de negócio de forma descobrível via `ListTools`
-- O projeto é um serviço de infraestrutura que deve ser consumível cross-framework
-
-**NÃO crie um MCP server quando:**
-
-- As tools são usadas apenas pelos agentes do próprio projeto → use tools nativas `[Description]`
-- É uma lógica de um único endpoint interno → `AIFunctionFactory.Create()` é suficiente
-- A integração é ponto-a-ponto com um único consumidor → DI direta ou A2A é mais simples
-
----
-
-## A API
-
-**Packages:**
-
-```xml
-<!-- SDK cliente+servidor do protocolo MCP -->
-<PackageReference Include="ModelContextProtocol" Version="0.1.*" />
-
-<!-- Pacote base MAF (para AsAIAgent, AsAIFunction) -->
-<PackageReference Include="Microsoft.Agents.AI" Version="1.0.*" />
-
-<!-- Apenas se o transporte for HTTP (server-side) -->
-<PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.1.*" />
-```
-
-> `ModelContextProtocol` versão 0.1.* (preview) — GA previsto. Verifique versão corrente no NuGet antes de travar.
-
-**Dois jeitos de declarar tools:**
-
-| Padrão | Quando usar |
-|--------|-------------|
-| Atributos `[McpServerToolType]` + `[McpServerTool]` | Tools são métodos estáticos do projeto — padrão canônico do SDK. Descoberta automática via `WithToolsFromAssembly()`. |
-| `McpServerTool.Create(...)` | Embrulhar um agente MAF (`agent.AsAIFunction()`) ou um `AIFunction` construído em runtime como tool. |
-
-**Padrão de servidor (stdio):**
-
-```
-Tools ([McpServerTool] ou McpServerTool.Create)
-    → services.AddMcpServer()            // registra o servidor
-    → .WithStdioServerTransport()        // transporte: stdio (Claude Code, subprocesso)
-    → .WithToolsFromAssembly()           // descobre [McpServerTool] no assembly
-       ou .WithTools([tool])             // registra tools criadas em runtime
-    → Host.Build().RunAsync()            // sobe o servidor
-```
-
-**Transport stdio** é o padrão para servidores locais (subprocessos, Claude Code tools). **HTTP server-side** usa o pacote `ModelContextProtocol.AspNetCore`: troque `WithStdioServerTransport()` por `WithHttpTransport(o => o.Stateless = true)` e exponha o endpoint com `app.MapMcp()` num `WebApplication`.
-
----
-
-## Exemplo C# — tools por atributo (stdio)
-
-Padrão canônico: tools são métodos estáticos decorados, descobertos por assembly.
-
-```csharp
-using System.ComponentModel;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using ModelContextProtocol.Server;
-
-HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
-
-builder.Services
-    .AddMcpServer()
-    .WithStdioServerTransport()    // stdio: Claude Code / subprocesso
-    .WithToolsFromAssembly();      // descobre [McpServerToolType] neste assembly
-
-await builder.Build().RunAsync();
-
-// ─── Tool exposta via atributo ──────────────────────────────────────────────
-[McpServerToolType]
-public static class OrderTools
-{
-    [McpServerTool, Description("Returns the current status of an order given its ID")]
-    public static async Task<string> GetOrderStatus(
-        [Description("The order identifier")] string orderId,
-        CancellationToken ct)
-    {
-        // Validação de input antes de qualquer I/O — ver seção Segurança
-        if (string.IsNullOrWhiteSpace(orderId) || orderId.Length > 36)
-            return "Error: invalid orderId format.";
-
-        // lógica real do projeto aqui
-        return $"Order {orderId}: Confirmed";
-    }
-}
-```
-
-> Tools por atributo podem ser instância (não-estáticas) — nesse caso o tipo é resolvido via DI,
-> permitindo injetar repositories/serviços no construtor. Métodos estáticos são o caso mais simples.
-
-## Exemplo C# — agente MAF como tool (runtime)
-
-Quando a tool é um agente MAF, use `McpServerTool.Create` com `agent.AsAIFunction()`:
-
-```csharp
-using Microsoft.Agents.AI;
-using Microsoft.Extensions.AI;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using ModelContextProtocol.Server;
-
-// _modelRegistry vem de ModelRegistry injetado (ai-agents-providers-model-registry)
-AIAgent queryAgent = _modelRegistry.GetChatClient("text-default")
-    .AsAIAgent(
-        instructions: "You answer questions about project data using the available tools.",
-        name: "ProjectQueryAgent");
-
-McpServerTool agentTool = McpServerTool.Create(queryAgent.AsAIFunction());
-
-HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
-
-builder.Services
-    .AddMcpServer()
-    .WithStdioServerTransport()
-    .WithTools([agentTool]);       // tool criada em runtime → WithTools, não WithToolsFromAssembly
-
-await builder.Build().RunAsync();
-```
-
-## Exemplo C# — transport HTTP
-
-Para expor o MCP server via HTTP (consumível pela rede), use `ModelContextProtocol.AspNetCore`:
-
-```csharp
-using ModelContextProtocol.Server;
-
-var builder = WebApplication.CreateBuilder(args);
-
-builder.Services
-    .AddMcpServer()
-    .WithHttpTransport(options => options.Stateless = true)  // stateless: escalável
-    .WithToolsFromAssembly();
-
-var app = builder.Build();
-
-app.MapMcp();   // expõe o endpoint MCP (Streamable HTTP)
-app.Run();
-```
-
-> `Stateless = true` é recomendado para servidores que não precisam de requests server-to-client
-> (sampling/elicitation) — escala melhor e dispensa gestão de sessão. Para HTTP em produção,
-> proteja `MapMcp()` com autenticação — ver seção Segurança.
-
-**Registrar no Claude Code (`settings.json` do projeto consumidor):**
-
-```json
-{
-  "mcpServers": {
-    "my-project-tools": {
-      "command": "dotnet",
-      "args": ["run", "--project", "src/MyProject.McpServer"]
-    }
-  }
-}
-```
-
----
-
-## Tool nativa vs MCP server exposto
-
-| Dimensão | Tool nativa (`[Description]`) | MCP server exposto |
-|----------|------------------------------|--------------------|
-| **Consumidor** | Agentes do próprio projeto | Agentes externos (Claude Code, outros projetos) |
-| **Protocolo** | Chamada direta em processo | Protocolo MCP (stdio ou HTTP) |
-| **Descoberta** | Registro manual no agente | `ListTools` — autodescoberta |
-| **Quando usar** | Lógica interna do projeto | Capacidades que cruzam fronteiras de projeto/processo |
-| **Overhead** | Zero | Processo separado, IPC via stdio/HTTP |
-| **Testabilidade** | Unitária com xUnit/nSubstitute | Requer host em execução ou mock do transport |
-
-**Regra**: se o único consumidor é um agente do próprio projeto → tool nativa. Se o consumidor é externo → MCP server.
-
----
-
-## Segurança
-
-Um MCP server exposto é uma **superfície de ataque real** — qualquer agente com acesso ao transporte pode invocar suas tools.
-
-**Obrigatório antes de expor:**
-
-- **Validação de input:** valide todos os parâmetros recebidos (IDs, datas, strings livres) antes de executar lógica de negócio. MCP não valida tipos por você.
-- **Escopo mínimo:** exponha apenas as tools necessárias. Não exponha operações de escrita se o consumidor só lê.
-- **Autenticação (HTTP transport):** se usar HTTP, exija bearer token ou API key via header. stdio é implicitamente restrito ao processo pai.
-- **Nunca expor secrets via tools:** tools não devem retornar API keys, tokens, ou dados de configuração interna.
-- **Rate limiting:** se o MCP server for exposto via HTTP em produção, adicione rate limiting na camada de transporte (reverse proxy / middleware ASP.NET).
-
-A validação de input é mostrada inline no exemplo `GetOrderStatus` acima — valide IDs/datas/strings
-**antes de qualquer I/O** e devolva uma mensagem de erro descritiva (o consumidor é um LLM, que
-corrige o argumento na próxima iteração). Para tools por atributo que precisam de repositories,
-prefira o tipo de instância resolvido por DI a métodos estáticos com estado global.
-
----
-
-## Anti-patterns
-
-| Anti-pattern | Problema | Solução |
-|-------------|---------|---------|
-| Criar MCP server para tools que só os agentes do próprio projeto usam | Overhead de processo + IPC sem benefício; mais difícil de testar | Tool nativa `[Description]` + `AIFunctionFactory.Create()` |
-| Expor tools sem validação de input | Agentes externos (ou alucinações de LLM) podem enviar dados malformados | Validar todos os parâmetros antes de qualquer I/O |
-| Tools sem escopo definido — expor tudo "por conveniência" | Superfície de ataque ampla; dificulta manutenção | Expor apenas o necessário; revisar a lista a cada release |
-| HTTP transport sem autenticação | Qualquer processo na rede pode invocar as tools | Bearer token / API key obrigatório em HTTP; stdio é suficiente para uso local |
-| Subir o MCP server no mesmo processo da aplicação principal | Acoplamento; falha no servidor MCP afeta a app | Projeto separado (`MyProject.McpServer`) com entrypoint próprio |
-
----
-
-## Checklist (verifiable by morph-eval)
-
-- [ ] `ModelContextProtocol` e `Microsoft.Agents.AI` no `.csproj`; `ModelContextProtocol.AspNetCore` apenas se HTTP
-- [ ] Tools declaradas via `[McpServerToolType]` + `[McpServerTool]` (estáticas) ou `McpServerTool.Create(...)` (agente MAF / runtime)
-- [ ] `AddMcpServer()` com `WithStdioServerTransport()` (stdio) ou `WithHttpTransport(o => o.Stateless = true)` (HTTP)
-- [ ] `WithToolsFromAssembly()` para tools por atributo, ou `WithTools([...])` para tools de runtime
-- [ ] Entrypoint: `await builder.Build().RunAsync()` (stdio) ou `app.MapMcp(); app.Run()` (HTTP)
-- [ ] Agente criado via `_modelRegistry.GetChatClient("alias").AsAIAgent(...)` — provider-agnostic
-- [ ] Validação de input em todas as tools antes de executar lógica de negócio
-- [ ] Escopo mínimo: apenas tools necessárias para o consumidor externo
-- [ ] HTTP transport (se usado) protegido por autenticação
-- [ ] Nenhum `Guid.NewGuid()` — usar `Guid.CreateVersion7()` se IDs são necessários
-
----
-
-## References
-
-- `ai-agents-setup` — pacotes base MAF, DI, quick start
-- `ai-agents-mcp-tools` — consumir MCP servers externos em um agente MAF
-- `ai-agents-production` — middleware pipeline, `ResilientToolMiddleware`, segurança
-- [ModelContextProtocol C# SDK](https://github.com/modelcontextprotocol/csharp-sdk)
-- [Expose Agent as MCP Server — MAF docs](https://learn.microsoft.com/en-us/agent-framework/agents/tools/local-mcp-tools)
-
----
-
-*MORPH-SPEC by Polymorphism Tech — ai-agents/mcp-server.md v1.0 (2026-05-19)*
+# MCP Server — Exposing project capabilities as MCP
+
+> **Scope:** stacks=["dotnet"]
+> **Layer:** 2 (on-keyword)
+> **Keywords:** mcp server, expose mcp, build mcp server, mcp host, publish tools, McpServerTool, AddMcpServer
+> **Read by Claude in:** implement (quando um projeto expõe capacidades como MCP server para consumo externo)
+
+**Verified against:** MAF 1.0 GA + ModelContextProtocol C# SDK server-side (`[McpServerToolType]`/`[McpServerTool]`, `WithStdioServerTransport`/`WithHttpTransport`, `ModelContextProtocol.AspNetCore`). Last-verified: 2026-05-19.
+
+---
+
+## Quando criar um MCP server
+
+Crie um MCP server quando você quer **expor capacidades do projeto** de forma padronizada para **agentes ou ferramentas externas** consumirem. O protocolo MCP garante interoperabilidade: qualquer agente compatível (Claude Code, outro agent MAF, VS Code Copilot, etc.) pode descobrir e usar as tools do servidor.
+
+**Crie um MCP server quando:**
+
+- Claude Code (ou outro agente externo) precisa executar queries/ações neste projeto
+- Outro projeto MAF precisa consumir lógica encapsulada aqui via protocolo padrão
+- Você quer expor capacidades de negócio de forma descobrível via `ListTools`
+- O projeto é um serviço de infraestrutura que deve ser consumível cross-framework
+
+**NÃO crie um MCP server quando:**
+
+- As tools são usadas apenas pelos agentes do próprio projeto → use tools nativas `[Description]`
+- É uma lógica de um único endpoint interno → `AIFunctionFactory.Create()` é suficiente
+- A integração é ponto-a-ponto com um único consumidor → DI direta ou A2A é mais simples
+
+---
+
+## A API
+
+**Packages:**
+
+```xml
+<!-- SDK cliente+servidor do protocolo MCP -->
+<PackageReference Include="ModelContextProtocol" Version="0.1.*" />
+
+<!-- Pacote base MAF (para AsAIAgent, AsAIFunction) -->
+<PackageReference Include="Microsoft.Agents.AI" Version="1.0.*" />
+
+<!-- Apenas se o transporte for HTTP (server-side) -->
+<PackageReference Include="ModelContextProtocol.AspNetCore" Version="0.1.*" />
+```
+
+> `ModelContextProtocol` versão 0.1.* (preview) — GA previsto. Verifique versão corrente no NuGet antes de travar.
+
+**Dois jeitos de declarar tools:**
+
+| Padrão | Quando usar |
+|--------|-------------|
+| Atributos `[McpServerToolType]` + `[McpServerTool]` | Tools são métodos estáticos do projeto — padrão canônico do SDK. Descoberta automática via `WithToolsFromAssembly()`. |
+| `McpServerTool.Create(...)` | Embrulhar um agente MAF (`agent.AsAIFunction()`) ou um `AIFunction` construído em runtime como tool. |
+
+**Padrão de servidor (stdio):**
+
+```
+Tools ([McpServerTool] ou McpServerTool.Create)
+    → services.AddMcpServer()            // registra o servidor
+    → .WithStdioServerTransport()        // transporte: stdio (Claude Code, subprocesso)
+    → .WithToolsFromAssembly()           // descobre [McpServerTool] no assembly
+       ou .WithTools([tool])             // registra tools criadas em runtime
+    → Host.Build().RunAsync()            // sobe o servidor
+```
+
+**Transport stdio** é o padrão para servidores locais (subprocessos, Claude Code tools). **HTTP server-side** usa o pacote `ModelContextProtocol.AspNetCore`: troque `WithStdioServerTransport()` por `WithHttpTransport(o => o.Stateless = true)` e exponha o endpoint com `app.MapMcp()` num `WebApplication`.
+
+---
+
+## Exemplo C# — tools por atributo (stdio)
+
+Padrão canônico: tools são métodos estáticos decorados, descobertos por assembly.
+
+```csharp
+using System.ComponentModel;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol.Server;
+
+HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()    // stdio: Claude Code / subprocesso
+    .WithToolsFromAssembly();      // descobre [McpServerToolType] neste assembly
+
+await builder.Build().RunAsync();
+
+// ─── Tool exposta via atributo ──────────────────────────────────────────────
+[McpServerToolType]
+public static class OrderTools
+{
+    [McpServerTool, Description("Returns the current status of an order given its ID")]
+    public static async Task<string> GetOrderStatus(
+        [Description("The order identifier")] string orderId,
+        CancellationToken ct)
+    {
+        // Validação de input antes de qualquer I/O — ver seção Segurança
+        if (string.IsNullOrWhiteSpace(orderId) || orderId.Length > 36)
+            return "Error: invalid orderId format.";
+
+        // lógica real do projeto aqui
+        return $"Order {orderId}: Confirmed";
+    }
+}
+```
+
+> Tools por atributo podem ser instância (não-estáticas) — nesse caso o tipo é resolvido via DI,
+> permitindo injetar repositories/serviços no construtor. Métodos estáticos são o caso mais simples.
+
+## Exemplo C# — agente MAF como tool (runtime)
+
+Quando a tool é um agente MAF, use `McpServerTool.Create` com `agent.AsAIFunction()`:
+
+```csharp
+using Microsoft.Agents.AI;
+using Microsoft.Extensions.AI;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using ModelContextProtocol.Server;
+
+// _modelRegistry vem de ModelRegistry injetado (ai-agents-providers-model-registry)
+AIAgent queryAgent = _modelRegistry.GetChatClient("text-default")
+    .AsAIAgent(
+        instructions: "You answer questions about project data using the available tools.",
+        name: "ProjectQueryAgent");
+
+McpServerTool agentTool = McpServerTool.Create(queryAgent.AsAIFunction());
+
+HostApplicationBuilder builder = Host.CreateApplicationBuilder(args);
+
+builder.Services
+    .AddMcpServer()
+    .WithStdioServerTransport()
+    .WithTools([agentTool]);       // tool criada em runtime → WithTools, não WithToolsFromAssembly
+
+await builder.Build().RunAsync();
+```
+
+## Exemplo C# — transport HTTP
+
+Para expor o MCP server via HTTP (consumível pela rede), use `ModelContextProtocol.AspNetCore`:
+
+```csharp
+using ModelContextProtocol.Server;
+
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services
+    .AddMcpServer()
+    .WithHttpTransport(options => options.Stateless = true)  // stateless: escalável
+    .WithToolsFromAssembly();
+
+var app = builder.Build();
+
+app.MapMcp();   // expõe o endpoint MCP (Streamable HTTP)
+app.Run();
+```
+
+> `Stateless = true` é recomendado para servidores que não precisam de requests server-to-client
+> (sampling/elicitation) — escala melhor e dispensa gestão de sessão. Para HTTP em produção,
+> proteja `MapMcp()` com autenticação — ver seção Segurança.
+
+**Registrar no Claude Code (`settings.json` do projeto consumidor):**
+
+```json
+{
+  "mcpServers": {
+    "my-project-tools": {
+      "command": "dotnet",
+      "args": ["run", "--project", "src/MyProject.McpServer"]
+    }
+  }
+}
+```
+
+---
+
+## Tool nativa vs MCP server exposto
+
+| Dimensão | Tool nativa (`[Description]`) | MCP server exposto |
+|----------|------------------------------|--------------------|
+| **Consumidor** | Agentes do próprio projeto | Agentes externos (Claude Code, outros projetos) |
+| **Protocolo** | Chamada direta em processo | Protocolo MCP (stdio ou HTTP) |
+| **Descoberta** | Registro manual no agente | `ListTools` — autodescoberta |
+| **Quando usar** | Lógica interna do projeto | Capacidades que cruzam fronteiras de projeto/processo |
+| **Overhead** | Zero | Processo separado, IPC via stdio/HTTP |
+| **Testabilidade** | Unitária com xUnit/nSubstitute | Requer host em execução ou mock do transport |
+
+**Regra**: se o único consumidor é um agente do próprio projeto → tool nativa. Se o consumidor é externo → MCP server.
+
+---
+
+## Segurança
+
+Um MCP server exposto é uma **superfície de ataque real** — qualquer agente com acesso ao transporte pode invocar suas tools.
+
+**Obrigatório antes de expor:**
+
+- **Validação de input:** valide todos os parâmetros recebidos (IDs, datas, strings livres) antes de executar lógica de negócio. MCP não valida tipos por você.
+- **Escopo mínimo:** exponha apenas as tools necessárias. Não exponha operações de escrita se o consumidor só lê.
+- **Autenticação (HTTP transport):** se usar HTTP, exija bearer token ou API key via header. stdio é implicitamente restrito ao processo pai.
+- **Nunca expor secrets via tools:** tools não devem retornar API keys, tokens, ou dados de configuração interna.
+- **Rate limiting:** se o MCP server for exposto via HTTP em produção, adicione rate limiting na camada de transporte (reverse proxy / middleware ASP.NET).
+
+A validação de input é mostrada inline no exemplo `GetOrderStatus` acima — valide IDs/datas/strings
+**antes de qualquer I/O** e devolva uma mensagem de erro descritiva (o consumidor é um LLM, que
+corrige o argumento na próxima iteração). Para tools por atributo que precisam de repositories,
+prefira o tipo de instância resolvido por DI a métodos estáticos com estado global.
+
+---
+
+## Anti-patterns
+
+| Anti-pattern | Problema | Solução |
+|-------------|---------|---------|
+| Criar MCP server para tools que só os agentes do próprio projeto usam | Overhead de processo + IPC sem benefício; mais difícil de testar | Tool nativa `[Description]` + `AIFunctionFactory.Create()` |
+| Expor tools sem validação de input | Agentes externos (ou alucinações de LLM) podem enviar dados malformados | Validar todos os parâmetros antes de qualquer I/O |
+| Tools sem escopo definido — expor tudo "por conveniência" | Superfície de ataque ampla; dificulta manutenção | Expor apenas o necessário; revisar a lista a cada release |
+| HTTP transport sem autenticação | Qualquer processo na rede pode invocar as tools | Bearer token / API key obrigatório em HTTP; stdio é suficiente para uso local |
+| Subir o MCP server no mesmo processo da aplicação principal | Acoplamento; falha no servidor MCP afeta a app | Projeto separado (`MyProject.McpServer`) com entrypoint próprio |
+
+---
+
+## Checklist (verifiable by morph-eval)
+
+- [ ] `ModelContextProtocol` e `Microsoft.Agents.AI` no `.csproj`; `ModelContextProtocol.AspNetCore` apenas se HTTP
+- [ ] Tools declaradas via `[McpServerToolType]` + `[McpServerTool]` (estáticas) ou `McpServerTool.Create(...)` (agente MAF / runtime)
+- [ ] `AddMcpServer()` com `WithStdioServerTransport()` (stdio) ou `WithHttpTransport(o => o.Stateless = true)` (HTTP)
+- [ ] `WithToolsFromAssembly()` para tools por atributo, ou `WithTools([...])` para tools de runtime
+- [ ] Entrypoint: `await builder.Build().RunAsync()` (stdio) ou `app.MapMcp(); app.Run()` (HTTP)
+- [ ] Agente criado via `_modelRegistry.GetChatClient("alias").AsAIAgent(...)` — provider-agnostic
+- [ ] Validação de input em todas as tools antes de executar lógica de negócio
+- [ ] Escopo mínimo: apenas tools necessárias para o consumidor externo
+- [ ] HTTP transport (se usado) protegido por autenticação
+- [ ] Nenhum `Guid.NewGuid()` — usar `Guid.CreateVersion7()` se IDs são necessários
+
+---
+
+## References
+
+- `ai-agents-setup` — pacotes base MAF, DI, quick start
+- `ai-agents-mcp-tools` — consumir MCP servers externos em um agente MAF
+- `ai-agents-production` — middleware pipeline, `ResilientToolMiddleware`, segurança
+- [ModelContextProtocol C# SDK](https://github.com/modelcontextprotocol/csharp-sdk)
+- [Expose Agent as MCP Server — MAF docs](https://learn.microsoft.com/en-us/agent-framework/agents/tools/local-mcp-tools)
+
+---
+
+*MORPH-SPEC by Polymorphism Tech — ai-agents/mcp-server.md v1.0 (2026-05-19)*