Sdílet prostřednictvím

Vytvoření agenta .NET OpenAI pomocí serveru MCP v Azure Container Apps

V tomto článku se dozvíte, jak vytvořit agenta PROTOKOLU MCP (Model Context Protocol) pomocí .NET. V této ukázce se klient MCP (napsaný v C#/.NET) připojuje k serveru MCP (napsaného v TypeScriptu) a spravuje seznam úkolů. Klient najde na serveru dostupné nástroje a odešle je do modelu Azure OpenAI. Uživatelé pak můžou komunikovat se systémem úkolů pomocí každodenního jazyka.

Získání kódu

Podívejte se na šablonu AI agenta OpenAI MCP. Tento příklad ukazuje, jak vytvořit agenta OpenAI, který používá klienta MCP k využívání existujícího serveru MCP.

Přejděte do části s návodem kódu, abyste pochopili, jak tato ukázka funguje.

Přehled architektury

Následující diagram znázorňuje jednoduchou architekturu ukázkové aplikace: Diagram znázorňující architekturu ze sady Visual Studio Code hostujícího agenta a klienta MCP na server MCP.

  • Klient MCP: Připojí se k serveru MCP a najde dostupné nástroje.
  • Chatovací klient: Pracuje s Azure OpenAI a rozumí přirozenému jazyku.
  • Uživatelské rozhraní Blazor: Poskytuje webové rozhraní, ve kterém můžou uživatelé chatovat.
  • Transport Layer: Používá Server-Sent události (SSE) k odesílání zpráv v reálném čase.
  • Ověřování: Používá tokeny JWT k zajištění zabezpečení připojení.

Server MCP běží jako kontejnerizovaná aplikace v Azure Container Apps (ACA). Používá back-end TypeScriptu k poskytování nástrojů klientovi MCP prostřednictvím protokolu Kontextu modelu. Všechny nástroje pracují s back-endovou databází SQLite.

Poznámka:

Navštivte stránku Sestavení serveru TypeScript MCP pomocí Azure Container Apps a podívejte se na návod kódu pro TypeScript MCP Server použitý v tomto článku.

Náklady

Pokud chcete zachovat nízké náklady, používá tato ukázka pro většinu prostředků základní cenové úrovně nebo cenové úrovně spotřeby. Podle potřeby upravte úroveň a odstraňte prostředky, abyste se vyhnuli poplatkům.

Požadavky

Vývojový kontejner obsahuje všechny závislosti, které potřebujete pro tento článek. Můžete ho spustit v GitHub Codespaces (v prohlížeči) nebo místně pomocí editoru Visual Studio Code.

Pokud chcete postupovat podle tohoto článku, ujistěte se, že splňujete tyto požadavky:

Nasazení modelu AI Foundry gpt-5-mini pomocí rozšíření AI Foundry VS Code

gpt-5-mini Nasaďte model pomocí rozšíření AI Foundry v editoru Visual Studio Code pomocí následujícího postupu:

Vytvoření projektu AI Foundry a nasazení modelu

Vytvoření připojovacího řetězce modelu OpenAI

  1. gpt-5-mini Po nasazení modelu klikněte pravým tlačítkem myši na model v rozšíření AI Foundry a vyberte Kopírovat klíč rozhraní API a zkopírujte klíč rozhraní API modelu do schránky.

  2. Potom klikněte pravým tlačítkem na nasazený gpt-5-mini model v rozšíření AI Foundry a vyberte Kopírovat koncový bod a zkopírujte koncový bod modelu do schránky, jak je znázorněno na následujícím snímku obrazovky:

    Snímek obrazovky znázorňující místní nabídku nasazeného modelu se zvýrazněnou možností Kopírovat koncový bod a Kopírovat klíč rozhraní API

  3. Nakonec vytvořte připojovací řetězec pro nasazený gpt-5-mini model pomocí zkopírovaného koncového bodu a klíče rozhraní API v následujícím formátu: Endpoint=<AZURE_OPENAI_ENDPOINT>;Key=<AZURE_OPENAI_API_KEY>. Tento připojovací řetězec budete potřebovat později v článku.

Otevřené vývojové prostředí

Podle těchto kroků nastavte předem nakonfigurované vývojové prostředí se všemi požadovanými závislostmi.

GitHub Codespaces spouští vývojový kontejner spravovaný GitHubem pomocí editoru Visual Studio Code pro web jako rozhraní. K nejjednoduššímu nastavení použijte GitHub Codespaces, protože obsahuje potřebné nástroje a závislosti předinstalované pro tento článek.

Důležité

Všechny účty GitHubu můžou každý měsíc používat Codespaces až 60 hodin zdarma se dvěma základními instancemi. Další informace najdete v tématu GitHub Codespaces měsíčně zahrnuté úložiště a hodiny jádra.

Pomocí následujícího postupu vytvořte nový GitHub Codespace ve main větvi Azure-Samples/openai-mcp-agent-dotnet úložiště GitHub.

  1. Klikněte pravým tlačítkem myši na následující tlačítko a vyberte Otevřít odkaz v novém okně. Tato akce umožňuje mít vývojové prostředí a otevřenou dokumentaci vedle sebe.

    Otevřít v GitHub Codespaces

  2. Na stránce Create codespace (Vytvořit kódový prostor ) zkontrolujte a pak vyberte Create new codespace (Vytvořit nový prostor kódu).

  3. Počkejte, až se prostor kódu spustí. Může to trvat několik minut.

  4. Ujistěte se, že je gpt-5-mininasazený název modelu . Pokud se nasazený model liší, aktualizujte src/McpTodo.ClientApp/appsettings.json ho správným názvem nasazení.

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

  5. Přihlaste se k Azure pomocí Azure Developer CLI v terminálu v dolní části obrazovky.

    azd auth login

  6. Zkopírujte kód z terminálu a vložte ho do prohlížeče. Postupujte podle pokynů k ověření pomocí účtu Azure.

Zbývající úlohy v tomto vývojovém kontejneru.

Poznámka:

Místní spuštění agenta MCP:

  1. Nastavte prostředí podle popisu v části Začínáme v ukázkovém úložišti.
  2. Nainstalujte server MCP podle pokynů v části Získat aplikaci serveru MCP v ukázkovém úložišti.
  3. Podle pokynů v části Spustit místně v ukázkovém úložišti spusťte agenta MCP místně.
  4. Pokračujte v části Použití agenta TODO MCP .

Nasazení a spuštění

Ukázkové úložiště obsahuje všechny soubory kódu a konfigurace pro nasazení agenta MCP v Azure. Následující kroky vás provedou ukázkovým procesem nasazení agenta MCP v Azure.

Nasazení do Azure

Důležité

Prostředky Azure v této části začnou okamžitě stát, i když příkaz zastavíte před dokončením.

Nastavení tokenu JWT

  • Nastavte token JWT pro server MCP spuštěním následujícího příkazu v terminálu v dolní části obrazovky:

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

    # PowerShell
./scripts/Set-JwtToken.ps1

Přidání tokenu JWT do konfigurace prostředí AZD

  1. Přidejte token JWT do konfigurace prostředí AZD spuštěním následujícího příkazu v terminálu v dolní části obrazovky:

    # 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

    Poznámka:

    Klientská aplikace MCP je ve výchozím nastavení chráněná integrovanou funkcí ověřování ACA. Tuto funkci můžete před spuštěním azd up vypnout nastavením:

    azd env set USE_LOGIN false

  2. Spusťte následující příkaz Azure Developer CLI pro zřizování prostředků Azure a nasazení zdrojového kódu:

    azd up

  3. Pomocí následující tabulky odpovězte na výzvy:

    Podnět Odpověď
    Název prostředí Použijte krátký název malými písmeny. Přidejte svoje jméno nebo alias. Například: my-mcp-agent. Název prostředí se stane součástí názvu skupiny prostředků.
    Subscription Zvolte předplatné, ve kterém chcete vytvářet prostředky.
    Umístění (pro hostování) V seznamu vyberte umístění nasazení modelu.
    Připojovací řetězec OpenAI Vložte připojovací řetězec pro model OpenAI, který jste vytvořili dříve v části Vytvoření připojovacího řetězce modelu OpenAI .

  4. Nasazení aplikace trvá 5 až 10 minut.

  5. Po dokončení nasazení můžete k agentu MCP přistupovat pomocí adresy URL ve výstupu. Adresa URL vypadá takto:

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

  6. Otevřete adresu URL ve webovém prohlížeči a použijte agenta MCP.

Použití agenta TODO MCP

Po spuštění agenta MCP můžete použít nástroje, které poskytuje v režimu agenta. Použití nástrojů MCP v režimu agenta:

  1. Přejděte na adresu URL klientské aplikace a přihlaste se k aplikaci.

    Poznámka:

    Pokud nastavíte USE_LOGIN hodnotu na falsehodnotu , pravděpodobně nebudete vyzváni k přihlášení.

  2. Do pole pro zadání chatu zadejte výzvu, například "Potřebuji poslat e-mail vedoucímu ve středu" a všimněte si, jak se nástroje automaticky volají podle potřeby.

  3. Agent MCP používá nástroje poskytované serverem MCP ke splnění požadavku a vrácení odpovědi v rozhraní chatu.

  4. Experimentujte s dalšími výzvami, jako jsou:

    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.

Prozkoumání kódu

Ukázkové úložiště obsahuje všechny soubory kódu a konfigurace pro nasazení agenta MCP v Azure. Následující části vás provedou klíčovými komponentami kódu agenta MCP.

Konfigurace a nastavení klienta MCP

Aplikace nastaví klienta MCP v Program.cs. Tato konfigurace definuje, jak se připojit a jaké možnosti použít. Kód používá několik pokročilých vzorů, včetně výchozích hodnot integrace a služby .NET Aspire:

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();
});

Klíčové podrobnosti implementace:

  • Konfigurace přenosu: SseClientTransportOptions Podporuje jak události Server-Sent (SSE), tak přenos HTTP s možností streamování. Metoda přenosu závisí na adrese URL koncového bodu – koncových bodech končících /sse na použití Server-Sent Events, zatímco koncové body končící /mcp na použití streamovatelného protokolu HTTP. Tento přístup umožňuje komunikaci mezi klientem a serverem v reálném čase.
  • Hlavičky ověřování: Tokeny JWT procházejí v AdditionalHeaders zabezpečení komunikace serveru.
  • Informace o klientovi: McpClientOptions sděluje serveru název a verzi klienta.
  • Model továrny: připojí a dokončí metodu handshake protokolu. McpClientFactory.CreateAsync()

Výchozí integrace služby .NET Aspire

Aplikace používá výchozí vzor služby .NET Aspire pro průřezové obavy:

// 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;
}

Výchozí výhody služby:

  • Kompozovatelné metody rozšíření: Systém používá vzor čistého tvůrce k přidání sdílených funkcí.
  • Standardní obslužné rutiny odolnosti: Systém za vás přidá předdefinované opakování, jistič a pravidla časového limitu.
  • Integrace zjišťování služeb: Systém vyhledá služby automaticky v kontejnerových prostředích.
  • OpenTelemetry ve výchozím nastavení: Systém získá úplné monitorování bez jakékoli instalace.

Následující diagram znázorňuje vztah mezi průřezovými obavami a aplikačními službami:

Diagram znázorňující vztah mezi průřezovými obavami a aplikačními službami

Řešení adresy URL konfigurace

Ukázka obsahuje sofistikované rozlišení adres URL pro různá prostředí:

// 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...
}

Funkce správy konfigurace:

  • Abstrakce zjišťování služeb: Systém zpracovává vývojové a produkční adresy URL čistě.
  • Vyjednávání protokolu: Systém nejprve zvolí PROTOKOL HTTPS a pak se vrátí zpět na HTTP.
  • Konvence konfigurace: Systém používá standardní vzory nastavení služby .NET Aspire.

Implementace ověřování

Tato ukázka používá ověřování JWT (webový token JSON) k zabezpečení připojení mezi klientem MCP a serverem.

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

Poznámka:

Skripty vytvořily proměnnou $TOKEN automaticky při spuštění skriptu Bash (set-jwttoken.sh) nebo PowerShellu (Set-JwtToken.ps1) dříve v části Nasazení do Azure . Tyto skripty provádějí následující kroky:

  1. Spuštění npm run generate-token v aplikaci serveru MCP pro vytvoření tokenu JWT
  2. Parsujte vygenerovaný .env soubor a extrahujte hodnotu JWT_TOKEN.
  3. Automaticky ho uložte do tajných kódů uživatelů .NET pro MCPClient.

Klient MCP načte token JWT z konfigurace a zahrne ho do hlaviček HTTP pro ověřování při připojování k serveru MCP:

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

Tento přístup zajišťuje:

  • Zabezpečená komunikace: Systém umožňuje klientům pouze s platnými tokeny připojit se k serveru MCP.
  • autorizaceToken-Based: Tokeny JWT umožňují systému ověřovat uživatele bez ukládání dat relace.
  • Správa konfigurace: Systém ukládá citlivé tokeny bezpečně do tajných kódů uživatelů během vývoje.

Integrace ověřování Azure Container Apps

Infrastruktura ukazuje pokročilé vzory ověřování pomocí integrovaných funkcí ověřování a autorizace v Azure Container Apps (Snadné ověřování):>

// 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
        }
      }
    }
  }
}

Pokročilé funkce ověřování:

  • ověřováníZero-Code: Azure Container Apps poskytuje integrované ověřování
  • Spravovaná identita pro úložiště: Systém bezpečně ukládá tokeny bez připojovacích řetězců.
  • Přihlašovací údaje federované identity: Systém umožňuje identitu úloh pro ověřování ve stylu Kubernetes.

Následující diagram znázorňuje handshake zabezpečení mezi komponentami:

Diagram znázorňující handshake zabezpečení mezi komponentami

Zjišťování a registrace nástrojů

Klient MCP zjišťuje dostupné nástroje ze serveru během inicializace součástí v Chat.razor:

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

Jak funguje zjišťování nástrojů:

  1. Dotaz serveru: McpClient.ListToolsAsync() Odešle požadavek na server MCP a zobrazí seznam dostupných nástrojů.
  2. Načtení schématu: Server odesílá zpět definice nástrojů s názvy, popisy a vstupními schématy.
  3. Registrace nástroje: Systém registruje nástroje s objektem ChatOptions a zpřístupní je klientovi OpenAI.
  4. Zabezpečení typu: Třída McpClientTool dědí z AIFunction, poskytuje bezproblémovou integraci s Microsoft.Extensions.AI

Následující diagram znázorňuje, jak se schémata nástrojů analyzují a registrují:

Diagram znázorňující tok zjišťování a registrace nástrojů

Integrace OpenAI a vyvolání funkcí

Konfigurace chatovacího klienta ukazuje, jak se nástroje MCP integrují s Azure OpenAI:

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

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

Výhody integrace:

  • Automatické volání funkcí: Rozšíření .UseFunctionInvocation() zapne automatické spouštění nástrojů na základě rozhodnutí LLM.
  • Snadný přístup k nástrojům: Nástroje MCP fungují jako integrované funkce pro model OpenAI
  • Zpracování odpovědí: Systém automaticky přidá výsledky nástrojů do toku konverzace.

implementace chatu Real-Time

Rozhraní chatu ukazuje Chat.razor odpovědi na streamování a spouštění nástrojů s pokročilými vzory Blazor:

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);
}

Funkce implementace streamování:

  • aktualizaceReal-Time: odesílá aktualizace odpovědí bit po bitu. GetStreamingResponseAsync()
  • Provádění nástrojů: Systém zpracovává volání funkce automaticky během streamování.
  • Rychlost odezvy uživatelského rozhraní: ChatMessageItem.NotifyChanged() Aktualizuje uživatelské rozhraní v reálném čase.
  • Podpora zrušení: Uživatelé můžou zrušit dlouhotrvající operace

Pokročilé vzory uživatelského rozhraní Blazor

Implementace používá pokročilé vzory uživatelského rozhraní pro aktualizace v reálném čase:

zpracování událostíMemory-Safe:

// 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();
    }
}

Integrace vlastních webových komponent:

// 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...
        });
    }
});

Pokročilá správa stavu:

// 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;
}

Výhody uživatelského rozhraní Blazor:

  • Hybridní webové komponenty: Systém kombinuje Blazor Server s vlastními prvky pro lepší výkon.
  • Memory-Safe zpracování událostí: Systém používá podmíněnouweakTable k prevenci nevracení paměti.
  • Inteligentní automatické posouvání: Systém poskytuje uživatelsky přívětivé chování chatu s debouncingem.
  • Řádné zrušení: Systém ukládá částečnou práci, když uživatelé zruší operace.

Tok požadavků a odpovědí

Tady je postup, jak typická interakce uživatelů prochází systémem:

  1. Uživatelský vstup: Uživatel zadá do seznamu úkolů zprávu typu Přidat nákup potravin.
  2. Zpracování zpráv: Systém přidá zprávu do historie konverzací.
  3. Analýza LLM: Azure OpenAI analyzuje požadavek a rozhodne, které nástroje se mají použít.
  4. Zjišťování nástrojů: Model najde správný nástroj MCP (například addTodo)
  5. Provádění nástrojů: Klient MCP volá server s potřebnými parametry.
  6. Zpracování odpovědí: Systém přidá odpověď serveru do konverzace.
  7. Aktualizace uživatelského rozhraní: Systém zobrazí výsledek uživateli v reálném čase.

Následující diagram znázorňuje tok zpráv ze vstupu uživatele přes OpenAI do provádění nástrojů a zpět do uživatelského rozhraní:

Diagram znázorňující tok požadavku nebo odpovědi

Asynchronní správa vzorů

Aplikace demonstruje sofistikované asynchronní vzory pro operace na pozadí:

// 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);
    }
}

Výhody úloh na pozadí:

  • Fire-and-Forget with Safety: Systém používá _ = vzor se správným zpracováním výjimek.
  • Snížení inteligentního kontextu: Systém omezuje historii konverzací, aby se zabránilo přetečení tokenu.
  • Inteligentní zrušení: Systém správně vyčistí konkurenční operace.

Zpracování chyb a odolnost proti chybám

Implementace zahrnuje několik vzorů odolnosti:

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;
}

Funkce odolnosti:

  • Řádné zrušení: Systém ukládá probíhající odpovědi, když je uživatelé zruší.
  • Obnovení připojení: Přenos SSE zpracovává automatické poklesy připojení
  • Správa stavu: Stav uživatelského rozhraní zůstává konzistentní během chyb.
  • Integrace protokolování: Systém poskytuje úplné protokolování pro ladění a monitorování.

Pozorovatelnost a kontroly stavu

Aplikace obsahuje sofistikované vzory pozorovatelnosti:

Konfigurace inteligentní kontroly stavu:

// 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 s inteligentním filtrováním:

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

Výhody pozorovatelnosti:

  • koncové bodyEnvironment-Aware: Ohrožení kontroly stavu při vědomí zabezpečení
  • Liveness vs Readiness: Vzory kontroly stavu ve stylu Kubernetes
  • Snížení šumu telemetrie: Filtrování rutinních kontrol stavu z trasování

Konfigurace a nastavení prostředí

Aplikace podporuje více prostředí prostřednictvím konfigurace:

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

Možnosti konfigurace:

  • Azure OpenAI: Produkční nasazení obvykle používají službu Azure OpenAI Service.
  • Modely GitHubu: Vývojové scénáře můžou používat modely GitHubu
  • Místní vývoj: Podpora místních instancí serveru MCP
  • Nasazení kontejnerů: Azure Container Apps pro hostování v produkčním prostředí

Vyčistěte zdroje

Po dokončení používání agenta MCP vyčistěte prostředky, které jste vytvořili, abyste se vyhnuli zbytečným nákladům.

Pokud chcete vyčistit prostředky, postupujte takto:

  • Odstraňte prostředky Azure vytvořené rozhraním příkazového řádku pro vývojáře Azure spuštěním následujícího příkazu v terminálu v dolní části obrazovky:

    azd down --purge --force

Vyčištění služby GitHub Codespaces

Odstraňte prostředí Codespaces GitHubu, abyste maximalizovali své bezplatné hodiny za jádro.

Důležité

Další informace o bezplatném úložišti a hodinách jádra vašeho účtu GitHubu najdete v tématu GitHub Codespaces měsíčně zahrnuté hodiny úložiště a jádra.

  1. Přihlaste se k řídicímu panelu Codespaces GitHubu.

  2. Vyhledejte aktivní codespaces vytvořené z Azure-Samples/openai-mcp-agent-dotnet úložiště GitHub.

  3. Otevřete místní nabídku pro codespace a vyberte Odstranit.

Získání pomoci

Zapište svůj problém do problémů úložiště.

  • Last updated on