Partilhar via

Criar um Agente OpenAI .NET usando um servidor MCP em Aplicativos de Contêiner do Azure

Este artigo mostra como criar um agente MCP (Model Context Protocol) usando o .NET. Neste exemplo, o cliente MCP (escrito em C#/.NET) se conecta a um servidor MCP (escrito em TypeScript) para gerenciar uma lista todo. O cliente encontra as ferramentas disponíveis no servidor e as envia para um modelo do Azure OpenAI. Os usuários podem então falar com o sistema todo usando a linguagem do dia a dia.

Ir para o código

Confira o modelo OpenAI MCP Agent Building Block AI. Este exemplo mostra como criar um agente OpenAI que usa um cliente MCP para consumir um servidor MCP existente.

Vá para a seção passo a passo do código para entender como esse exemplo funciona.

Visão geral da arquitetura

O diagrama a seguir mostra a arquitetura simples do aplicativo de exemplo: Diagrama mostrando a arquitetura do Visual Studio Code hospedando o agente e o cliente MCP para o MCP Server.

  • Cliente MCP: Conecta-se ao servidor MCP e encontra as ferramentas disponíveis
  • Cliente de bate-papo: funciona com o Azure OpenAI para entender a linguagem natural
  • Blazor UI: Fornece uma interface web onde os usuários podem conversar
  • Camada de transporte: usa eventos Server-Sent (SSE) para enviar mensagens em tempo real
  • Autenticação: usa tokens JWT para manter a conexão segura

O servidor MCP é executado como um aplicativo em contêiner nos Aplicativos de Contêiner do Azure (ACA). Ele usa um back-end TypeScript para fornecer ferramentas para o cliente MCP através do protocolo de contexto de modelo. Todas as ferramentas funcionam com um banco de dados SQLite back-end.

Observação

Visite Criar um servidor MCP TypeScript usando Aplicativos de Contêiner do Azure para ver o passo a passo do código do Servidor MCP TypeScript usado neste artigo.

Custo

Para manter os custos baixos, este exemplo usa níveis de preços básicos ou de consumo para a maioria dos recursos. Ajuste a camada conforme necessário e exclua recursos quando terminar para evitar cobranças.

Pré-requisitos

Um contêiner de desenvolvimento inclui todas as dependências necessárias para este artigo. Você pode executá-lo no GitHub Codespaces (em um navegador) ou localmente usando o Visual Studio Code.

Para seguir este artigo, certifique-se de que cumpre estes pré-requisitos:

Implante um modelo gpt-5-mini do AI Foundry usando a extensão de código VS do AI Foundry

Implante um gpt-5-mini modelo usando a extensão AI Foundry no Visual Studio Code usando as seguintes etapas:

Crie um projeto AI Foundry e implante o modelo

Criar a cadeia de conexão OpenAI Model

  1. Depois que o gpt-5-mini modelo for implantado, clique com o botão direito do mouse no modelo na extensão AI Foundry e selecione Copiar chave da API para copiar a chave da API do modelo para a área de transferência.

  2. Em seguida, clique com o botão direito do mouse no modelo implantado gpt-5-mini na extensão AI Foundry e selecione Copiar ponto de extremidade para copiar o ponto de extremidade do modelo para a área de transferência, conforme mostrado na captura de tela a seguir:

    Captura de tela mostrando o menu de contexto para o modelo implantado com as opções de chave Copiar ponto de extremidade e Copiar API realçadas.

  3. Por fim, crie uma cadeia de conexão para o modelo implantado gpt-5-mini usando o ponto de extremidade copiado e a chave da API no seguinte formato: Endpoint=<AZURE_OPENAI_ENDPOINT>;Key=<AZURE_OPENAI_API_KEY>. Você precisa dessa cadeia de conexão mais adiante no artigo.

Ambiente de desenvolvimento aberto

Siga estas etapas para configurar um ambiente de desenvolvimento pré-configurado com todas as dependências necessárias.

O GitHub Codespaces executa um contêiner de desenvolvimento gerenciado pelo GitHub com o Visual Studio Code for the Web como interface. Use o GitHub Codespaces para a configuração mais simples, pois ele vem com as ferramentas e dependências necessárias pré-instaladas para este artigo.

Importante

Todas as contas do GitHub podem usar Codespaces por até 60 horas gratuitas por mês com duas instâncias principais. Para obter mais informações, consulte GitHub Codespaces mensalmente incluído armazenamento e horas principais.

Use as etapas a seguir para criar um novo espaço de código do GitHub na main ramificação do Azure-Samples/openai-mcp-agent-dotnet repositório do GitHub.

  1. Clique com o botão direito do mouse no botão a seguir e selecione Abrir link na nova janela. Esta ação permite que você tenha o ambiente de desenvolvimento e a documentação abertos lado a lado.

    Abrir no Codespaces do GitHub

  2. Na página Criar espaço de código , revise e selecione Criar novo espaço de código.

  3. Aguarde até que o espaço de código inicie. Pode demorar alguns minutos.

  4. Verifique se o nome do modelo implantado é gpt-5-mini. Se o modelo implantado for diferente, atualize src/McpTodo.ClientApp/appsettings.json com o nome de implantação correto.

    {
  "OpenAI": {
    // Make sure this is the right deployment name.
    "DeploymentName": "gpt-5-mini"
  }
}

  5. Entre no Azure com a CLI do Desenvolvedor do Azure no terminal na parte inferior da tela.

    azd auth login

  6. Copie o código do terminal e cole-o em um navegador. Siga as instruções para autenticar com sua conta do Azure.

Você executa o restante das tarefas neste contêiner de desenvolvimento.

Observação

Para executar o agente MCP localmente:

  1. Configure seu ambiente conforme descrito na seção Introdução no repositório de exemplo.
  2. Instale o servidor MCP seguindo as instruções na seção Obter aplicativo do servidor MCP no repositório de exemplo.
  3. Execute o agente MCP localmente seguindo as instruções na seção Executar localmente no repositório de exemplo.
  4. Vá para a seção Usar o agente TODO MCP para continuar.

Implantar e executar

O repositório de exemplo contém todos os arquivos de código e configuração para a implantação do Azure do agente MCP. As etapas a seguir orientam você pelo processo de implantação do Azure do agente MCP de exemplo.

Implantar no Azure

Importante

Os recursos do Azure nesta seção começam a custar dinheiro imediatamente, mesmo que você pare o comando antes que ele seja concluído.

Definir o token JWT

  • Defina o token JWT para o servidor MCP executando o seguinte comando no terminal na parte inferior da tela:

    # zsh/bash
./scripts/set-jwttoken.sh

    # PowerShell
./scripts/Set-JwtToken.ps1

Adicionar token JWT à configuração do ambiente azd

  1. Adicione o token JWT à configuração do ambiente azd executando o seguinte comando no terminal na parte inferior da tela:

    # zsh/bash
env_dir=".azure/$(azd env get-value AZURE_ENV_NAME)"
mkdir -p "$env_dir"
cat ./src/McpTodo.ServerApp/.env >> "$env_dir/.env"

    # PowerShell
$dotenv = Get-Content ./src/McpTodo.ServerApp/.env
$dotenv | Add-Content -Path ./.azure/$(azd env get-value AZURE_ENV_NAME)/.env -Encoding utf8 -Force

    Observação

    Por padrão, o aplicativo cliente MCP é protegido pelo recurso de autenticação interno ACA. Você pode desativar esse recurso antes de executar azd up pela configuração:

    azd env set USE_LOGIN false

  2. Execute o seguinte comando da CLI do Desenvolvedor do Azure para provisionamento de recursos do Azure e implantação de código-fonte:

    azd up

  3. Use a tabela a seguir para responder aos prompts:

    Pronta Resposta
    Nome do ambiente Use um nome curto e minúsculo. Adicione o seu nome ou alias. Por exemplo, my-mcp-agent. O nome do ambiente torna-se parte do nome do grupo de recursos.
    Subscription Escolha a subscrição onde pretende criar recursos.
    Localização (para hospedagem) Escolha o local de implantação do modelo na lista.
    Cadeia de conexão OpenAI Cole a cadeia de conexão para o modelo OpenAI que você criou anteriormente na seção Criar a cadeia de conexão do Modelo OpenAI .

  4. A implantação do aplicativo leva de 5 a 10 minutos.

  5. Após a conclusão da implantação, você pode acessar o agente MCP usando a URL na saída. O URL tem esta aparência:

    https://<env-name>.<container-id>.<region>.azurecontainerapps.io

  6. Abra a URL em um navegador da Web para usar o agente MCP.

Usar o agente TODO MCP

Depois que o agente MCP estiver em execução, você poderá usar as ferramentas que ele fornece no modo de agente. Para usar ferramentas MCP no modo de agente:

  1. Navegue até a URL do aplicativo cliente e entre no aplicativo.

    Observação

    Se definir o USE_LOGIN valor como false, poderá não lhe ser pedido para iniciar sessão.

  2. Digite um prompt como "Preciso enviar um e-mail para meu gerente na quarta-feira" na caixa de entrada do bate-papo e observe como as ferramentas são invocadas automaticamente conforme necessário.

  3. O agente MCP usa as ferramentas fornecidas pelo servidor MCP para atender à solicitação e retornar uma resposta na interface de chat.

  4. Experimente outros prompts como:

    Give me a list of to dos.
Set "meeting at 1pm".
Give me a list of to dos.
Mark #1 as completed.
Delete #1 from the to-do list.

Explore o código

O repositório de exemplo contém todos os arquivos de código e configuração para a implantação do Azure do agente MCP. As seções a seguir orientam você pelos principais componentes do código do agente MCP.

Configuração e configuração do Cliente MCP

O aplicativo configura o cliente MCP no Program.cs. Essa configuração define como se conectar e quais opções usar. O código usa vários padrões avançados, incluindo integração com o .NET Aspire e padrões de serviço:

builder.Services.AddSingleton<IMcpClient>(sp =>
{
    var config = sp.GetRequiredService<IConfiguration>();
    var loggerFactory = sp.GetRequiredService<ILoggerFactory>();

    var uri = new Uri(config["McpServers:TodoList"]!);

    var clientTransportOptions = new SseClientTransportOptions()
    {
        Endpoint = new Uri($"{uri.AbsoluteUri.TrimEnd('/')}/mcp"),
        AdditionalHeaders = new Dictionary<string, string>
        {
            { "Authorization", $"Bearer {config["McpServers:JWT:Token"]!}" }
        }
    };
    var clientTransport = new SseClientTransport(clientTransportOptions, loggerFactory);

    var clientOptions = new McpClientOptions()
    {
        ClientInfo = new Implementation()
        {
            Name = "MCP Todo Client",
            Version = "1.0.0",
        }
    };

    return McpClientFactory.CreateAsync(clientTransport, clientOptions, loggerFactory).GetAwaiter().GetResult();
});

Principais detalhes da implementação:

  • Configuração de transporte: SseClientTransportOptions suporta eventos de Server-Sent (SSE) e transporte HTTP streamable. O método de transporte depende da URL do ponto de extremidade - pontos de extremidade que terminam com /sse o uso Server-Sent Eventos, enquanto os pontos de extremidade terminam com /mcp o uso de HTTP streamable. Essa abordagem permite a comunicação em tempo real entre cliente e servidor
  • Cabeçalhos de autenticação: os tokens JWT entram no para manter a AdditionalHeaders comunicação do servidor segura
  • Informações do cliente: McpClientOptions informa ao servidor o nome e a versão do cliente
  • Padrão de fábrica: McpClientFactory.CreateAsync() conecta e completa o handshake de protocolo

Integração padrão do serviço .NET Aspire

O aplicativo usa o padrão de padrões de serviço do .NET Aspire para preocupações transversais:

// McpTodo.ServiceDefaults/Extensions.cs
public static TBuilder AddServiceDefaults<TBuilder>(this TBuilder builder) where TBuilder : IHostApplicationBuilder
{
    builder.ConfigureOpenTelemetry();
    builder.AddDefaultHealthChecks();
    builder.Services.AddServiceDiscovery();
    
    builder.Services.ConfigureHttpClientDefaults(http =>
    {
        // Turn on resilience by default
        http.AddStandardResilienceHandler();
        // Turn on service discovery by default
        http.AddServiceDiscovery();
    });
    
    return builder;
}

Benefícios padrão do serviço:

  • Métodos de extensão compostáveis: O sistema usa um padrão de construtor limpo para adicionar recursos compartilhados
  • Manipuladores de resiliência padrão: o sistema adiciona regras internas de repetição, disjuntor e tempo limite para você
  • Integração de descoberta de serviços: o sistema encontra serviços automaticamente em ambientes de contêiner
  • OpenTelemetry por padrão: O sistema recebe monitoramento completo sem qualquer trabalho de configuração

O diagrama a seguir mostra a relação entre preocupações transversais e serviços de aplicativos:

Diagrama mostrando a relação entre preocupações transversais e serviços de aplicativos.

Resolução de URL de configuração

O exemplo inclui resolução de URL sofisticada para diferentes ambientes:

// AspireUrlParserExtensions.cs
public static Uri Resolve(this Uri uri, IConfiguration config)
{
    var absoluteUrl = uri.ToString();
    if (absoluteUrl.StartsWith("https+http://"))
    {
        var appname = absoluteUrl.Substring("https+http://".Length).Split('/')[0];
        var https = config[$"services:{appname}:https:0"]!;
        var http = config[$"services:{appname}:http:0"]!;
        
        return string.IsNullOrWhiteSpace(https) ? new Uri(http) : new Uri(https);
    }
    // Handle other URL formats...
}

Recursos de gerenciamento de configuração:

  • Abstração de descoberta de serviço: o sistema lida com URLs de desenvolvimento e produção de forma limpa
  • Negociação de protocolo: O sistema escolhe HTTPS primeiro, depois volta para HTTP
  • Convenção de configuração: O sistema usa padrões padrão de configuração do serviço .NET Aspire

Implementação de autenticação

Este exemplo usa a autenticação JWT (JSON Web Token) para proteger a conexão entre o cliente MCP e o servidor.

dotnet user-secrets --project ./src/McpTodo.ClientApp set McpServers:JWT:Token "$TOKEN"

Observação

Os scripts criaram a $TOKEN variável automaticamente quando você executou o script Bash (set-jwttoken.sh) ou PowerShell (Set-JwtToken.ps1) anteriormente na seção Implantar no Azure . Esses scripts executam as seguintes etapas:

  1. Executar npm run generate-token no aplicativo de servidor MCP para criar um token JWT
  2. Analise o arquivo gerado .env para extrair o valor JWT_TOKEN
  3. Armazená-lo automaticamente em segredos de usuário .NET para o MCPClient

O cliente MCP recupera o token JWT da configuração e o inclui nos cabeçalhos HTTP para autenticação ao se conectar ao servidor MCP:

AdditionalHeaders = new Dictionary<string, string>
{
    { "Authorization", $"Bearer {config["McpServers:JWT:Token"]!}" }
}

Esta abordagem garante:

  • Comunicação segura: O sistema só permite que clientes com tokens válidos se conectem ao servidor MCP
  • Token-Based Autorização: os tokens JWT permitem que o sistema verifique os usuários sem armazenar dados da sessão
  • Gerenciamento de configuração: O sistema armazena tokens confidenciais com segurança em segredos do usuário durante o desenvolvimento

Integração de autenticação de aplicativos de contêiner do Azure

A infraestrutura mostra padrões de autenticação avançados usando os recursos internos de autenticação e autorização dos Aplicativos de Contêiner do Azure ("Easy Auth"):

// containerapps-authconfigs.bicep
resource containerappAuthConfig 'Microsoft.App/containerApps/authConfigs@2024-10-02-preview' = {
  properties: {
    identityProviders: {
      azureActiveDirectory: {
        enabled: true
        registration: {
          clientId: clientId
          openIdIssuer: openIdIssuer
        }
      }
    }
    login: {
      tokenStore: {
        enabled: true
        azureBlobStorage: {
          blobContainerUri: '${storageAccount.properties.primaryEndpoints.blob}/token-store'
          managedIdentityResourceId: userAssignedIdentity.id
        }
      }
    }
  }
}

Recursos avançados de autenticação:

  • AutenticaçãoZero-Code: Aplicativos de Contêiner do Azure fornece autenticação interna
  • Identidade gerenciada para armazenamento: o sistema armazena tokens com segurança sem cadeias de conexão
  • Credenciais de identidade federada: o sistema habilita a identidade da carga de trabalho para autenticação no estilo Kubernetes

O diagrama a seguir mostra o handshake de segurança entre componentes:

Diagrama mostrando o handshake de segurança entre componentes.

Descoberta e registro de ferramentas

O cliente MCP descobre as ferramentas disponíveis do servidor durante a inicialização do componente em Chat.razor:

protected override async Task OnInitializedAsync()
{
    messages.Add(new(ChatRole.System, SystemPrompt));
    tools = await McpClient.ListToolsAsync();
    chatOptions.Tools = [.. tools];
}

Como funciona a descoberta de ferramentas:

  1. Consulta ao servidor: McpClient.ListToolsAsync() envia uma solicitação ao servidor MCP para listar as ferramentas disponíveis
  2. Recuperação de esquema: o servidor envia de volta definições de ferramenta com nomes, descrições e esquemas de entrada
  3. Registro da ferramenta: O sistema registra as ferramentas com o ChatOptions objeto, disponibilizando-as para o cliente OpenAI
  4. Tipo de Segurança: A McpClientTool classe herda de AIFunction, proporcionando uma integração suave com Microsoft.Extensions.AI

O diagrama a seguir mostra como os esquemas de ferramentas são analisados e registrados:

Diagrama mostrando a descoberta da ferramenta e o fluxo de registro.

Integração OpenAI e invocação de funções

A configuração do cliente de chat demonstra como as ferramentas MCP se integram ao Azure OpenAI:

var chatClient = openAIClient.GetChatClient(config["OpenAI:DeploymentName"]).AsIChatClient();

builder.Services.AddChatClient(chatClient)
                .UseFunctionInvocation()
                .UseLogging();

Benefícios da integração:

  • Chamada de função automática: A .UseFunctionInvocation() extensão ativa a execução automática de ferramentas com base em decisões LLM
  • Easy Tool Access: As ferramentas MCP funcionam como funções integradas para o modelo OpenAI
  • Processamento de respostas: O sistema adiciona automaticamente os resultados da ferramenta ao fluxo de conversação

Real-Time implementação de chat

A interface de bate-papo demonstra Chat.razor respostas de streaming e execução de ferramentas com padrões Blazor avançados:

private async Task AddUserMessageAsync(ChatMessage userMessage)
{
    CancelAnyCurrentResponse();

    // Add the user message to the conversation
    messages.Add(userMessage);
    chatSuggestions?.Clear();
    await chatInput!.FocusAsync();

    // Stream and display a new response from the IChatClient
    var responseText = new TextContent("");
    currentResponseMessage = new ChatMessage(ChatRole.Assistant, [responseText]);
    currentResponseCancellation = new();
    await foreach (var update in ChatClient.GetStreamingResponseAsync([.. messages], chatOptions, currentResponseCancellation.Token))
    {
        messages.AddMessages(update, filter: c => c is not TextContent);
        responseText.Text += update.Text;
        ChatMessageItem.NotifyChanged(currentResponseMessage);
    }

    // Store the final response in the conversation, and begin getting suggestions
    messages.Add(currentResponseMessage!);
    currentResponseMessage = null;
    chatSuggestions?.Update(messages);
}

Recursos de implementação de streaming:

  • Real-Time Updates: GetStreamingResponseAsync() envia atualizações de resposta pouco a pouco
  • Execução da ferramenta: O sistema processa chamadas de função automaticamente durante o streaming
  • Capacidade de resposta da interface do usuário: ChatMessageItem.NotifyChanged() atualiza a interface do usuário em tempo real
  • Suporte a cancelamento: os usuários podem cancelar operações de longa duração

Padrões avançados de interface do usuário Blazor

A implementação usa padrões avançados de interface do usuário para atualizações em tempo real:

Memory-Safe manipulação de eventos:

// ChatMessageItem.razor
private static readonly ConditionalWeakTable<ChatMessage, ChatMessageItem> SubscribersLookup = new();

public static void NotifyChanged(ChatMessage source)
{
    if (SubscribersLookup.TryGetValue(source, out var subscriber))
    {
        subscriber.StateHasChanged();
    }
}

Integração de componentes Web personalizados:

// ChatMessageList.razor.js
window.customElements.define('chat-messages', class ChatMessages extends HTMLElement {
    connectedCallback() {
        this._observer = new MutationObserver(mutations => this._scheduleAutoScroll(mutations));
        this._observer.observe(this, { childList: true, attributes: true });
    }
    
    _scheduleAutoScroll(mutations) {
        // Debounce the calls and handle smart auto-scrolling
        cancelAnimationFrame(this._nextAutoScroll);
        this._nextAutoScroll = requestAnimationFrame(() => {
            const addedUserMessage = mutations.some(m => 
                Array.from(m.addedNodes).some(n => 
                    n.parentElement === this && n.classList?.contains('user-message')));
            // Smart scrolling logic...
        });
    }
});

Gestão avançada do estado:

// Chat.razor
private void CancelAnyCurrentResponse()
{
    // If a response was cancelled while streaming, include it in the conversation so it's not lost
    if (currentResponseMessage is not null)
    {
        messages.Add(currentResponseMessage);
    }
    
    currentResponseCancellation?.Cancel();
    currentResponseMessage = null;
}

Benefícios da Blazor UI:

  • Componentes Web híbridos: O sistema combina Blazor Server com elementos personalizados para um melhor desempenho
  • Memory-Safe Event Handling: O sistema usa ConditionalWeakTable para evitar vazamentos de memória
  • Smart Auto-Scrolling: O sistema fornece um comportamento de bate-papo amigável com debouncing
  • Cancelamento gracioso: O sistema economiza trabalho parcial quando os usuários cancelam operações

Fluxo de solicitação/resposta

Veja como uma interação típica do usuário flui através do sistema:

  1. Entrada do usuário: O usuário digita uma mensagem como "Adicionar 'Comprar mantimentos' à minha lista de tarefas"
  2. Processamento de mensagens: o sistema adiciona a mensagem ao histórico de conversas
  3. Análise LLM: O Azure OpenAI analisa a solicitação e decide quais ferramentas usar
  4. Descoberta de ferramentas: o modelo encontra a ferramenta MCP certa (por exemplo, addTodo)
  5. Execução da ferramenta: O cliente MCP chama o servidor com os parâmetros necessários
  6. Processamento de resposta: O sistema adiciona a resposta do servidor à conversa
  7. UI Update: O sistema mostra o resultado para o usuário em tempo real

O diagrama a seguir mostra como as mensagens fluem da entrada do usuário através do OpenAI para a execução da ferramenta e de volta para a interface do usuário:

Diagrama mostrando o fluxo de solicitação/resposta.

Gerenciamento de padrões assíncronos

O aplicativo demonstra padrões assíncronos sofisticados para operações em segundo plano:

// ChatSuggestions.razor
public void Update(IReadOnlyList<ChatMessage> messages)
{
    // Runs in the background and handles its own cancellation/errors
    _ = UpdateSuggestionsAsync(messages);
}

private async Task UpdateSuggestionsAsync(IReadOnlyList<ChatMessage> messages)
{
    cancellation?.Cancel();
    cancellation = new CancellationTokenSource();
    
    try
    {
        var response = await ChatClient.GetResponseAsync<string[]>(
            [.. ReduceMessages(messages), new(ChatRole.User, Prompt)],
            cancellationToken: cancellation.Token);
        // Handle response...
    }
    catch (Exception ex) when (ex is not OperationCanceledException)
    {
        await DispatchExceptionAsync(ex);
    }
}

Benefícios da tarefa em segundo plano:

  • Incêndio e Esqueça com Segurança: O sistema usa _ = padrão com manuseio adequado de exceções
  • Redução inteligente de contexto: o sistema limita o histórico de conversas para evitar o estouro de token
  • Cancelamento inteligente: O sistema limpa adequadamente as operações concorrentes

Tratamento de erros e resiliência

A implementação inclui vários padrões de resiliência:

private void CancelAnyCurrentResponse()
{
    // If a response was cancelled while streaming, include it in the conversation so it's not lost
    if (currentResponseMessage is not null)
    {
        messages.Add(currentResponseMessage);
    }

    currentResponseCancellation?.Cancel();
    currentResponseMessage = null;
}

Características de resiliência:

  • Cancelamento normal: O sistema salva respostas em andamento quando os usuários as cancelam
  • Recuperação de conexão: O transporte SSE lida com quedas de conexão automaticamente
  • Gerenciamento de Estado: O estado da interface do usuário permanece consistente durante erros
  • Integração de log: O sistema fornece registro completo para depuração e monitoramento

Observabilidade e controlos sanitários

A aplicação inclui padrões de observabilidade sofisticados:

Configuração de verificação de integridade inteligente:

// Extensions.cs
public static WebApplication MapDefaultEndpoints(this WebApplication app)
{
    if (app.Environment.IsDevelopment())
    {
        // All health checks must pass for app to be considered ready
        app.MapHealthChecks(HealthEndpointPath);
        
        // Only health checks tagged with "live" must pass for app to be considered alive
        app.MapHealthChecks(AlivenessEndpointPath, new HealthCheckOptions
        {
            Predicate = r => r.Tags.Contains("live")
        });
    }
    return app;
}

OpenTelemetry com filtragem inteligente:

// Extensions.cs
.AddAspNetCoreInstrumentation(tracing =>
    // Exclude health check requests from tracing
    tracing.Filter = context =>
        !context.Request.Path.StartsWithSegments(HealthEndpointPath)
        && !context.Request.Path.StartsWithSegments(AlivenessEndpointPath)
)

Benefícios da observabilidade:

  • Environment-Aware Parâmetros: Exposição a verificações de saúde conscientes da segurança
  • Liveness vs Readiness: padrões de verificação de saúde no estilo Kubernetes
  • Redução de ruído de telemetria: filtrando verificações de integridade de rotina de rastreamentos

Configuração e configuração do ambiente

A aplicação suporta vários ambientes através da configuração:

var openAIClient = Constants.GitHubModelEndpoints.Contains(endpoint.TrimEnd('/'))
                   ? new OpenAIClient(credential, openAIOptions)
                   : new AzureOpenAIClient(new Uri(endpoint), credential);

Opções de configuração:

  • Azure OpenAI: as implantações de produção normalmente usam o Serviço OpenAI do Azure
  • Modelos do GitHub: Os cenários de desenvolvimento podem usar os modelos do GitHub
  • Desenvolvimento Local: Suporte para instâncias locais do servidor MCP
  • Implantação de contêiner: Aplicativos de contêiner do Azure para hospedagem de produção

Limpeza de recursos

Depois de terminar de usar o agente MCP, limpe os recursos criados para evitar incorrer em custos desnecessários.

Para limpar recursos, siga estes passos:

  • Exclua os recursos do Azure criados pela CLI do Desenvolvedor do Azure executando o seguinte comando no terminal na parte inferior da tela:

    azd down --purge --force

Limpar espaços de código do GitHub

Exclua o ambiente do GitHub Codespaces para maximizar suas horas gratuitas por núcleo.

Importante

Para obter mais informações sobre o armazenamento gratuito e as horas principais da sua conta do GitHub, consulte Armazenamento mensal incluído e horas principais do GitHub Codespaces.

  1. Entre no painel do GitHub Codespaces.

  2. Encontre seus Codespaces ativos criados a partir do Azure-Samples/openai-mcp-agent-dotnet repositório GitHub.

  3. Abra o menu de contexto do espaço de código e selecione Excluir.

Obter ajuda

Registre seu problema nos problemas do repositório.

  • Last updated on