Aracılığıyla paylaş

Azure İşlevleri (Dayanıklı)

Microsoft Agent Framework için dayanıklı görev uzantısı, Azure'da sunucusuz bir ortamda durum bilgisi olan yapay zeka aracıları ve çok aracılı belirlenimci düzenlemeler oluşturmanıza olanak tanır.

Azure İşlevleri , altyapıyı yönetmeden isteğe bağlı kod çalıştırmanızı sağlayan sunucusuz bir işlem hizmetidir. Dayanıklı görev uzantısı, dayanıklı durum yönetimi sağlamak için bu temeli temel alır. Bu, aracınızın konuşma geçmişinin ve yürütme durumunun güvenilir bir şekilde kalıcı olduğu ve hatalardan, yeniden başlatmalardan ve uzun süre çalışan işlemlerden kurtulduğu anlamına gelir.

Genel Bakış

Dayanıklı aracılar, Aşağıdaki aracıları oluşturmak için Agent Framework'ün gücünü Azure Dayanıklı İşlevler ile birleştirir:

  • İşlev çağrıları arasında durumu otomatik olarak kalıcı hale
  • Konuşma bağlamı kaybetmeden hatalardan sonra devam et
  • İsteğe bağlı olarak otomatik olarak ölçeklendirme
  • Çok aracılı iş akışlarını güvenilir yürütme garantileriyle düzenleme

Dayanıklı aracılar ne zaman kullanılır?

İhtiyaç duyduğunuzda dayanıklı etkenleri seçin.

  • Tam kod denetimi: Sunucusuz avantajları korurken kendi işlem ortamınızı dağıtma ve yönetme
  • Karmaşık düzenleme: Günler veya haftalarca çalışabilen belirleyici, güvenilir iş akışlarıyla birden çok aracıyı koordine edin
  • Olay odaklı orkestrasyon: Olay temelli aracı iş akışları için Azure İşlevleri tetikleyicileri (HTTP, zamanlayıcılar, kuyruklar vb.) ve bağlantılarla tümleştirme
  • Otomatik konuşma durumu: Aracı konuşma geçmişi, kodunuzda açık durum işlemeye gerek kalmadan otomatik olarak yönetilir ve kalıcı haleilir

Bu sunucusuz barındırma yaklaşımı, Azure İşlevleri uygulamalarını dağıtmanıza veya yönetmenize gerek kalmadan tam olarak yönetilen altyapı sağlayan yönetilen hizmet tabanlı aracı barındırmadan (Azure AI Foundry Aracı Hizmeti gibi) farklıdır. Dayanıklı ajanlar, kod öncelikli dağıtım esnekliği ile dayanıklı durum yönetiminin güvenilirliğine aynı anda ihtiyaç duyduğunuzda idealdir.

Azure İşlevleri Esnek Tüketim barındırma planında barındırıldığında, aracılar kullanımda olmadığında binlerce örneğe veya sıfır örneğe ölçeklendirilebilir ve yalnızca ihtiyacınız olan işlem için ödeme yapmanıza olanak tanır.

Başlangıç Yapmak

.NET Azure İşlevleri projesinde gerekli NuGet paketlerini ekleyin.

dotnet add package Azure.AI.OpenAI --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.OpenAI --prerelease
dotnet add package Microsoft.Agents.AI.Hosting.AzureFunctions --prerelease

Uyarı

Bu paketlere ek olarak, projenizin Microsoft.Azure.Functions.Worker paketinin 2.2.0 veya sonraki bir sürümünü kullandığından emin olun.

Python Azure İşlevleri projesinde gerekli Python paketlerini yükleyin.

pip install azure-identity
pip install agent-framework-azurefunctions --pre

Sunucusuz barındırma

Dayanıklı görev uzantısıyla, yerleşik HTTP uç noktaları ve düzenleme tabanlı çağırma ile Azure İşlevleri'nde Microsoft Agent Framework aracılarını dağıtabilir ve barındırabilirsiniz. Azure İşlevleri, otomatik ölçeklendirme ve minimum altyapı yönetimi ile olay odaklı, çağrı başına ödeme fiyatlandırması sağlar.

Dayanıklı bir aracı yapılandırdığınızda, dayanıklı görev uzantısı aracınız için otomatik olarak HTTP uç noktaları oluşturur ve konuşma durumunu depolamak, eşzamanlı istekleri işlemek ve çok aracılı iş akışlarını koordine etmek için temel alınan tüm altyapıyı yönetir.

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        instructions: "You are good at telling jokes.",
        name: "Joker");

// Configure the function app to host the agent with durable thread management
// This automatically creates HTTP endpoints and manages state persistence
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
        options.AddAIAgent(agent)
    )
    .Build();
app.Run();

import os
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o-mini")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are good at telling jokes.",
    name="Joker"
)

# Configure the function app to host the agent with durable thread management
# This automatically creates HTTP endpoints and manages state persistence
app = AgentFunctionApp(agents=[agent])

Konuşma geçmişiyle durum bilgisi olan aracı iş parçacıkları

Ajanlar, birden çok etkileşimde kalıcı iş parçacığı tutar. Her iş parçacığı benzersiz bir iş parçacığı kimliğiyle tanımlanır ve konuşma geçmişinin tamamını Dayanıklı Görev Zamanlayıcı tarafından yönetilen dayanıklı depolamada depolar.

Bu desen, işlem kilitlenmeleri ve yeniden başlatmalar sırasında aracının durumunu koruyarak konuşmaların sürekliliğini sağlar ve kullanıcı iş parçacıklarında konuşma geçmişinin eksiksiz bir şekilde korunmasına olanak tanır. Dayanıklı depolama, Azure İşlevleri örneğiniz yeniden başlatılıp farklı bir örneğe ölçeklendirilse bile konuşmanın kaldığı yerden sorunsuz bir şekilde devam etmesini sağlar.

Aşağıdaki örnek, konuşma bağlamlarının nasıl kalıcı olduğunu gösteren aynı iş parçacığına yönelik birden çok HTTP isteğini gösterir:

# First interaction - start a new thread
curl -X POST https://your-function-app.azurewebsites.net/api/agents/Joker/run \
  -H "Content-Type: text/plain" \
  -d "Tell me a joke about pirates"

# Response includes thread ID in x-ms-thread-id header and joke as plain text
# HTTP/1.1 200 OK
# Content-Type: text/plain
# x-ms-thread-id: @dafx-joker@263fa373-fa01-4705-abf2-5a114c2bb87d
#
# Why don't pirates shower before they walk the plank? Because they'll just wash up on shore later!

# Second interaction - continue the same thread with context
curl -X POST "https://your-function-app.azurewebsites.net/api/agents/Joker/run?thread_id=@dafx-joker@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Tell me another one about the same topic"

# Agent remembers the pirate context from the first message and responds with plain text
# What's a pirate's favorite letter? You'd think it's R, but it's actually the C!

Aracı durumu dayanıklı depolamada tutulur ve birden fazla örnek arasında dağıtılmış çalıştırma gerçekleştirir. Herhangi bir örnek, kesintiler veya arızalar sonrasında bir ajanın yürütülmesini sürdürerek sürekli işlemi sağlayabilir.

Belirlenimci çok aracılı düzenleme

Dayanıklı görev uzantısı , Azure Dayanıklı İşlevler düzenlemelerini kullanarak birden çok aracıyı koordine eden belirlenebilen iş akışları oluşturulmasını destekler.

Düzenleme, birden çok işlemi (aracı çağrıları, dış API çağrıları veya zamanlayıcılar gibi) güvenilir bir şekilde koordine eden kod tabanlı iş akışlarıdır. Belirleyici , düzenleme kodunun bir hatadan sonra yeniden oynatıldığında aynı şekilde yürütülerek iş akışlarının güvenilir ve hata ayıklanabilir hale getirilmesi anlamına gelir. Düzenleme geçmişini yeniden oynattığınızda, her adımda tam olarak ne olduğunu görebilirsiniz.

Orkestrasyonlar, aracı çağrıları arasında güvenilir bir şekilde çalışır ve hatalardan etkilenmeden devam eder, öngörülebilir ve yinelenebilir işlemler sağlar. Bu, bunları, garantili yürütme sırasına ve hataya dayanıklılık düzeyine ihtiyaç duyduğunuz karmaşık çok aracılı senaryolar için ideal hale getirir.

Sıralı düzenleme

Sıralı çoklu etmen deseninde, özel etmenler belirli bir sırayla çalıştırılır ve her etmenin çıktısı, bir sonraki etmenin çalışmasını etkileyebilir. Bu örüntü, aracı yanıtlarına göre koşullu mantığı ve dallanmayı destekler.

Orkestrasyonlarda aracıları kullanırken, kayıtlı aracılarınızdan birini saran standart context.GetAgent() türünün özel bir alt sınıfı olan DurableAIAgent örneğini elde etmek için AIAgent API'sini kullanmanız gerekir. Sarmalayıcı, DurableAIAgent aracı çağrılarının dayanıklı düzenleme çerçevesi tarafından düzgün bir şekilde izlenmesini ve denetlenmesini sağlar.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(SpamDetectionOrchestration))]
public static async Task<string> SpamDetectionOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    Email email = context.GetInput<Email>();

    // Check if the email is spam
    DurableAIAgent spamDetectionAgent = context.GetAgent("SpamDetectionAgent");
    AgentSession spamSession = await spamDetectionAgent.CreateSessionAsync();

    AgentResponse<DetectionResult> spamDetectionResponse = await spamDetectionAgent.RunAsync<DetectionResult>(
        message: $"Analyze this email for spam: {email.EmailContent}",
        session: spamSession);
    DetectionResult result = spamDetectionResponse.Result;

    if (result.IsSpam)
    {
        return await context.CallActivityAsync<string>(nameof(HandleSpamEmail), result.Reason);
    }

    // Generate response for legitimate email
    DurableAIAgent emailAssistantAgent = context.GetAgent("EmailAssistantAgent");
    AgentSession emailSession = await emailAssistantAgent.CreateSessionAsync();

    AgentResponse<EmailResponse> emailAssistantResponse = await emailAssistantAgent.RunAsync<EmailResponse>(
        message: $"Draft a professional response to: {email.EmailContent}",
        session: emailSession);

    return await context.CallActivityAsync<string>(nameof(SendEmail), emailAssistantResponse.Result.Response);
}

Orkestrasyonlarda aracıları kullanırken, kayıtlı aracılarınızdan birinin etrafında özel bir sarmalayıcı olan dayanıklı bir aracı örneği almak için app.get_agent() yöntemini kullanmanız gerekir. Dayanıklı temsilci sarmalayıcı, temsilci çağrılarının dayanıklı orkestrasyon çerçevesi tarafından doğru bir şekilde izlenmesini ve kontrol edilmesini sağlar.

import azure.durable_functions as df
from typing import cast
from agent_framework.azure import AgentFunctionApp
from pydantic import BaseModel

class SpamDetectionResult(BaseModel):
    is_spam: bool
    reason: str

class EmailResponse(BaseModel):
    response: str

app = AgentFunctionApp(agents=[spam_detection_agent, email_assistant_agent])

@app.orchestration_trigger(context_name="context")
def spam_detection_orchestration(context: df.DurableOrchestrationContext):
    email = context.get_input()

    # Check if the email is spam
    spam_agent = app.get_agent(context, "SpamDetectionAgent")
    spam_thread = spam_agent.create_session()

    spam_result_raw = yield spam_agent.run(
        messages=f"Analyze this email for spam: {email['content']}",
        session=spam_thread,
        response_format=SpamDetectionResult
    )
    spam_result = cast(SpamDetectionResult, spam_result_raw.get("structured_response"))

    if spam_result.is_spam:
        result = yield context.call_activity("handle_spam_email", spam_result.reason)
        return result

    # Generate response for legitimate email
    email_agent = app.get_agent(context, "EmailAssistantAgent")
    email_thread = email_agent.create_session()

    email_response_raw = yield email_agent.run(
        messages=f"Draft a professional response to: {email['content']}",
        session=email_thread,
        response_format=EmailResponse
    )
    email_response = cast(EmailResponse, email_response_raw.get("structured_response"))

    result = yield context.call_activity("send_email", email_response.response)
    return result

Orkestrasyonlar, birden çok aracı arasında çalışmaları koordine eder ve ajan çağrıları arasındaki hatalara rağmen çalışmaya devam eder. Orkestrasyon bağlamı, orkestrasyonlarda barındırılan aracıları almak ve bunlarla etkileşime geçmek için yöntemler sağlar.

Paralel düzenleme

Paralel çok aracılı desende, birden çok aracıyı eşzamanlı olarak yürütür ve sonra bunların sonuçlarını toplarsınız. Bu desen, farklı perspektifleri toplamak veya bağımsız alt görevleri aynı anda işlemek için kullanışlıdır.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ResearchOrchestration))]
public static async Task<string> ResearchOrchestration(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Execute multiple research agents in parallel
    DurableAIAgent technicalAgent = context.GetAgent("TechnicalResearchAgent");
    DurableAIAgent marketAgent = context.GetAgent("MarketResearchAgent");
    DurableAIAgent competitorAgent = context.GetAgent("CompetitorResearchAgent");

    // Start all agent runs concurrently
    Task<AgentResponse<TextResponse>> technicalTask = 
        technicalAgent.RunAsync<TextResponse>($"Research technical aspects of {topic}");
    Task<AgentResponse<TextResponse>> marketTask = 
        marketAgent.RunAsync<TextResponse>($"Research market trends for {topic}");
    Task<AgentResponse<TextResponse>> competitorTask = 
        competitorAgent.RunAsync<TextResponse>($"Research competitors in {topic}");

    // Wait for all tasks to complete
    await Task.WhenAll(technicalTask, marketTask, competitorTask);

    // Aggregate results
    string allResearch = string.Join("\n\n", 
        technicalTask.Result.Result.Text,
        marketTask.Result.Result.Text,
        competitorTask.Result.Result.Text);

    DurableAIAgent summaryAgent = context.GetAgent("SummaryAgent");
    AgentResponse<TextResponse> summaryResponse = 
        await summaryAgent.RunAsync<TextResponse>($"Summarize this research:\n{allResearch}");

    return summaryResponse.Result.Text;
}

import azure.durable_functions as df
from agent_framework.azure import AgentFunctionApp

app = AgentFunctionApp(agents=[technical_agent, market_agent, competitor_agent, summary_agent])

@app.orchestration_trigger(context_name="context")
def research_orchestration(context: df.DurableOrchestrationContext):
    topic = context.get_input()

    # Execute multiple research agents in parallel
    technical_agent = app.get_agent(context, "TechnicalResearchAgent")
    market_agent = app.get_agent(context, "MarketResearchAgent")
    competitor_agent = app.get_agent(context, "CompetitorResearchAgent")

    technical_task = technical_agent.run(messages=f"Research technical aspects of {topic}")
    market_task = market_agent.run(messages=f"Research market trends for {topic}")
    competitor_task = competitor_agent.run(messages=f"Research competitors in {topic}")

    # Wait for all tasks to complete
    results = yield context.task_all([technical_task, market_task, competitor_task])

    # Aggregate results
    all_research = "\n\n".join([r.get('response', '') for r in results])

    summary_agent = app.get_agent(context, "SummaryAgent")
    summary = yield summary_agent.run(messages=f"Summarize this research:\n{all_research}")

    return summary.get('response', '')

Paralel yürütme, bir görev listesi kullanılarak izlenir. Otomatik kontrol noktası oluşturma, toplama sırasında bir hata oluşursa, tamamlanmış ajan yürütmelerinin tekrarlanmamasını veya kaybolmamasını sağlar.

Döngüde insan düzenlemesi

Deterministik acente orkestrasyonları, işlem kaynaklarını kullanmadan insan girişi, onayı veya gözden geçirmesi için duraklatılabilir. Dayanıklı yürütme, orkestrasyonların insan yanıtlarını beklerken günler, hatta haftalarca beklemesine olanak tanır. Sunucusuz barındırma ile birleştirildiğinde, bekleme süresi boyunca tüm işlem kaynakları devre dışı bırakılır ve insan girdilerini sağlayana kadar işlem maliyetlerini ortadan kaldırır.

using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;
using Microsoft.Agents.AI.DurableTask;

[Function(nameof(ContentApprovalWorkflow))]
public static async Task<string> ContentApprovalWorkflow(
    [OrchestrationTrigger] TaskOrchestrationContext context)
{
    string topic = context.GetInput<string>();

    // Generate content using an agent
    DurableAIAgent contentAgent = context.GetAgent("ContentGenerationAgent");
    AgentResponse<GeneratedContent> contentResponse = 
        await contentAgent.RunAsync<GeneratedContent>($"Write an article about {topic}");
    GeneratedContent draftContent = contentResponse.Result;

    // Send for human review
    await context.CallActivityAsync(nameof(NotifyReviewer), draftContent);

    // Wait for approval with timeout
    HumanApprovalResponse approvalResponse;
    try
    {
        approvalResponse = await context.WaitForExternalEvent<HumanApprovalResponse>(
            eventName: "ApprovalDecision",
            timeout: TimeSpan.FromHours(24));
    }
    catch (OperationCanceledException)
    {
        // Timeout occurred - escalate for review
        return await context.CallActivityAsync<string>(nameof(EscalateForReview), draftContent);
    }

    if (approvalResponse.Approved)
    {
        return await context.CallActivityAsync<string>(nameof(PublishContent), draftContent);
    }

    return "Content rejected";
}

import azure.durable_functions as df
from datetime import timedelta
from agent_framework.azure import AgentFunctionApp

app = AgentFunctionApp(agents=[content_agent])

@app.orchestration_trigger(context_name="context")
def content_approval_workflow(context: df.DurableOrchestrationContext):
    topic = context.get_input()

    # Generate content using an agent
    content_agent = app.get_agent(context, "ContentGenerationAgent")
    draft_content = yield content_agent.run(
        messages=f"Write an article about {topic}"
    )

    # Send for human review
    yield context.call_activity("notify_reviewer", draft_content)

    # Wait for approval with timeout
    approval_task = context.wait_for_external_event("ApprovalDecision")
    timeout_task = context.create_timer(
        context.current_utc_datetime + timedelta(hours=24)
    )

    winner = yield context.task_any([approval_task, timeout_task])

    if winner == approval_task:
        timeout_task.cancel()
        approval_data = approval_task.result
        if approval_data.get("approved"):
            result = yield context.call_activity("publish_content", draft_content)
            return result
        return "Content rejected"

    # Timeout occurred - escalate for review
    result = yield context.call_activity("escalate_for_review", draft_content)
    return result

Belirlenimci aracı düzenlemeleri, dış olayları beklerken durumlarını kalıcı bir şekilde saklayabilir, insan geri bildirimini beklerken hatalara dayanabilir, yeniden başlatmalara ve uzun bekleme sürelerine dayanabilir. İnsan yanıtı geldiğinde, tüm konuşma bağlamı ve yürütme durumu bozulmadan, orkestrasyon otomatik olarak devam eder.

İnsan girişi sağlama

Bekleyen bir düzenlemeye onay veya giriş göndermek için Dayanıklı İşlevler istemci SDK'sını kullanarak düzenleme örneğine bir dış olay oluşturun. Örneğin gözden geçiren, şu çağrıları yapan bir web formu aracılığıyla içeriği onaylayabilir:

await client.RaiseEventAsync(instanceId, "ApprovalDecision", new HumanApprovalResponse 
{ 
    Approved = true,
    Feedback = "Looks great!"
});

approval_data = {
    "approved": True,
    "feedback": "Looks great!"
}
await client.raise_event(instance_id, "ApprovalDecision", approval_data)

Maliyet verimliliği

Dayanıklı aracılara sahip döngüdeki insan iş akışları , Azure İşlevleri Esnek Tüketim planında barındırıldığında son derece uygun maliyetlidir. Onay için 24 saat bekleyen bir iş akışı için yalnızca birkaç saniyelik yürütme süresi (içerik oluşturma, bildirim gönderme ve yanıtı işleme süresi) ödersiniz; 24 saatlik bekleme süresi için değil. Bekleme süresi boyunca hiçbir işlem kaynağı tüketilmemiş.

Dayanıklı Görev Zamanlayıcı ile Gözlemlenebilirlik

Dayanıklı Görev Zamanlayıcı (DTS), dayanıklı aracılarınız için önerilen dayanıklı arka uç olup bir kullanıcı arabirimi panosu aracılığıyla en iyi performansı, tam olarak yönetilen altyapıyı ve yerleşik gözlemlenebilirliği sunar. Azure İşlevleri diğer depolama arka uçlarını (Azure Depolama gibi) kullanabilir ancak DTS, dayanıklı iş yükleri için özel olarak iyileştirilmiştir ve üstün performans ve izleme özellikleri sağlar.

Aracı oturumu içgörüleri

  • Konuşma geçmişi: Her aracı oturumu için, herhangi bir zamanda tüm iletiler, araç aramaları ve konuşma bağlamı dahil olmak üzere tam sohbet geçmişini görüntüleyin.
  • Görev zamanlaması: Belirli görevlerin ve aracı etkileşimlerinin tamamlanmasının ne kadar süreceğini izleme

Konuşma yazışmaları ve iletileriyle aracı sohbet geçmişini gösteren Dayanıklı Görev Zamanlayıcı panosunun ekran görüntüsü.

Düzenleme içgörüleri

  • Çok aracılı görselleştirme: Paralel yürütmelerin ve koşullu dallanmanın görsel gösterimiyle birden çok özel aracı çağrılırken yürütme akışına bakın
  • Yürütme geçmişi: Ayrıntılı yürütme günlüklerine erişme
  • Gerçek zamanlı izleme: Dağıtımınız genelinde etkin orkestrasyonları, kuyruğa alınan iş öğelerini ve aracı durumlarını izleyin
  • Performans ölçümleri: Aracı yanıt sürelerini, belirteç kullanımını ve düzenleme süresini izleme

Çok sayıda aracın etkileşimi ve iş akışı yürütmesini içeren orkestrasyon görselleştirmesini gösteren Dayanıklı Görev Zamanlayıcı panosunun ekran görüntüsü.

Hata ayıklama özellikleri

  • Yapılandırılmış ajan çıktıları ve araç çağrısı sonuçlarını görüntüleyin
  • İzleme aracı çağrıları ve bunların sonuçları
  • İnsan unsurunun devrede olduğu senaryolar için harici olay yönetimini izleme

Pano, aracılarınızın tam olarak ne yaptığını anlamanıza, sorunları hızla tanılamanıza ve gerçek yürütme verilerine göre performansı iyileştirmenize olanak tanır.

Öğretici: Dayanıklı aracı oluşturma ve çalıştırma

Bu öğreticide, Microsoft Agent Framework için dayanıklı görev uzantısını kullanarak dayanıklı bir yapay zeka aracısı oluşturma ve çalıştırma işlemi gösterilmektedir. Durum bilgisine sahip bir ajanı yerleşik HTTP uç noktalarıyla barındıran bir Azure İşlevleri uygulaması oluşturacak ve Dayanıklı Görev Zamanlayıcı kontrol panelini kullanarak bunu nasıl izleyeceğinizi öğreneceksiniz.

Önkoşullar

Başlamadan önce aşağıdaki önkoşullara sahip olduğunuzdan emin olun:

Uyarı

Microsoft Agent Framework, .NET'in etkin olarak desteklenen tüm sürümleriyle desteklenir. Bu örneğin amaçları doğrultusunda .NET 9 SDK'sını veya sonraki bir sürümü öneririz.

Hızlı başlangıç projesini indirme

Dayanıklı aracılar hızlı başlangıç şablonundan yeni bir proje başlatmak için Azure Geliştirici CLI'sini kullanın.

  1. Projeniz için yeni bir dizin oluşturun ve bu dizine gidin:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Projeyi şablondan başlatın:

    azd init --template durable-agents-quickstart-dotnet

    Ortam adı istendiğinde, my-durable-agent gibi bir ad girin.

Bu işlem Azure İşlevleri yapılandırması, aracı kodu ve kod şablonları olarak altyapı dahil olmak üzere gerekli tüm dosyaları içeren hızlı başlangıç projesini indirir.

  1. Projeniz için yeni bir dizin oluşturun ve bu dizine gidin:

    mkdir MyDurableAgent
cd MyDurableAgent

  1. Projeyi şablondan başlatın:

    azd init --template durable-agents-quickstart-python

    Ortam adı istendiğinde, my-durable-agent gibi bir ad girin.

  2. Sanal ortam oluşturma ve etkinleştirme:

    python3 -m venv .venv
source .venv/bin/activate

  1. Gerekli paketleri yükleyin:

    python -m pip install -r requirements.txt

Bu işlem Azure İşlevleri yapılandırması, aracı kodu ve kod şablonları olarak altyapı dahil olmak üzere gerekli tüm dosyaları içeren hızlı başlangıç projesini indirir. Ayrıca gerekli bağımlılıklara sahip bir sanal ortam hazırlar.

Azure kaynaklarını sağlama

Dayanıklı aracınız için gerekli Azure kaynaklarını oluşturmak için Azure Geliştirici CLI'sini kullanın.

  1. Altyapıyı sağlama:

    azd provision

    Bu komut şunu oluşturur:

    • gpt-4o-mini dağıtımına sahip bir Azure OpenAI hizmeti
    • Flex Consumption barındırma planına sahip bir Azure İşlevleri uygulaması
    • Azure İşlevleri çalışma zamanı ve dayanıklı depolama için bir Azure Depolama hesabı
    • Aracı durumunu yönetmek için Dayanıklı Görev Zamanlayıcı örneği (Tüketim planı)
    • Gerekli ağ ve kimlik yapılandırmaları

  2. İstendiğinde Azure aboneliğinizi seçin ve kaynaklar için bir konum seçin.

Sağlama işlemi birkaç dakika sürer. İşlem tamamlandıktan sonra azd, oluşturulan kaynak bilgilerini ortamınızda depolar.

Aracı kodunu gözden geçirme

Şimdi dayanıklı aracınızı tanımlayan kodu inceleyelim.

Aracı yapılandırmasını görmek için açın Program.cs :

using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.AI;
using Microsoft.Extensions.Hosting;
using OpenAI;

var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") 
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT environment variable is not set");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT") ?? "gpt-4o-mini";

// Create an AI agent following the standard Microsoft Agent Framework pattern
AIAgent agent = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsAIAgent(
        instructions: "You are a helpful assistant that can answer questions and provide information.",
        name: "MyDurableAgent");

using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options => options.AddAIAgent(agent))
    .Build();
app.Run();

Bu kod:

  1. Azure OpenAI yapılandırmanızı ortam değişkenlerinden alır.
  2. Azure kimlik bilgilerini kullanarak bir Azure OpenAI istemcisi oluşturur.
  3. Yönergeler ve bir ad ile bir yapay zeka aracısı oluşturur.
  4. Azure İşlevleri uygulamasını, aracıyı dayanıklı iş parçacığı yönetimi sağlayarak barındıracak şekilde yapılandırır.

Aracı yapılandırmasını görmek için açın function_app.py :

import os
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp
from azure.identity import DefaultAzureCredential

endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME", "gpt-4o-mini")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    credential=DefaultAzureCredential()
).as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Configure the function app to host the agent with durable thread management
app = AgentFunctionApp(agents=[agent])

Bu kod:

  • Azure OpenAI yapılandırmanızı ortam değişkenlerinden alır.
  • Azure kimlik bilgilerini kullanarak bir Azure OpenAI istemcisi oluşturur.
  • Yönergeler ve bir ad ile bir yapay zeka aracısı oluşturur.
  • Azure İşlevleri uygulamasını, aracıyı dayanıklı iş parçacığı yönetimi sağlayarak barındıracak şekilde yapılandırır.

Aracı artık Azure İşlevleri'nde barındırılmaya hazırdır. Dayanıklı görev uzantısı aracınızla etkileşim için otomatik olarak HTTP uç noktaları oluşturur ve birden çok istekte konuşma durumunu yönetir.

Yerel ayarları yapılandırma

Projeye dahil edilen örnek dosyayı temel alarak yerel geliştirme için bir local.settings.json dosya oluşturun.

  1. Örnek ayarlar dosyasını kopyalayın:

    cp local.settings.sample.json local.settings.json

  1. Sağlanan kaynaklardan Azure OpenAI uç noktanızı alın:

    azd env get-value AZURE_OPENAI_ENDPOINT

  2. Açın local.settings.json ve <your-resource-name> değerini önceki komutun uç noktasına göre AZURE_OPENAI_ENDPOINT ile değiştirin.

Aşağıdaki local.settings.json gibi görünmelidir:

{
  "IsEncrypted": false,
  "Values": {
    // ... other settings ...
    "AZURE_OPENAI_ENDPOINT": "https://your-openai-resource.openai.azure.com",
    "AZURE_OPENAI_DEPLOYMENT": "gpt-4o-mini",
    "TASKHUB_NAME": "default"
  }
}

Uyarı

Dosya local.settings.json yalnızca yerel geliştirme için kullanılır ve Azure'a dağıtılmaz. Üretim dağıtımları için bu ayarlar Azure İşlevleri uygulamanızda altyapı şablonları tarafından otomatik olarak yapılandırılır.

Yerel geliştirme bağımlılıklarını başlat

Dayanıklı acenteleri yerel olarak çalıştırmak için iki hizmeti başlatmanız gerekir.

  • Azurite: Azure Depolama hizmetlerini öykünür (tetikleyicileri ve iç durumu yönetmek için Azure İşlevleri tarafından kullanılır).
  • Dayanıklı Görev Zamanlayıcı (DTS) öykünücüsü: Aracılarınız için dayanıklı durumu (konuşma geçmişi, orkestrasyon durumu) ve zamanlamayı yönetir

Azurite'i başlatma

Azurite, Azure Depolama hizmetlerini yerel olarak taklit eder. Azure İşlevleri bunu iç durumu yönetmek için kullanır. Dayanıklı yazılımınızı geliştirip test ederken bunu yeni bir terminal penceresinde çalıştırmanız ve açık tutmanız gerekir.

  1. Yeni bir terminal penceresi açın ve Azurite Docker görüntüsünü çekin:

    docker pull mcr.microsoft.com/azure-storage/azurite

  2. Terminal penceresinde Azurite'i başlatın:

    docker run -p 10000:10000 -p 10001:10001 -p 10002:10002 mcr.microsoft.com/azure-storage/azurite

    Azurite, Blob (10000), Kuyruk (10001) ve Tablo (10002) hizmetleri için varsayılan bağlantı noktalarını başlatır ve dinler.

Dayanıklı yazılım ajanınızı geliştirirken ve test ederken bu terminal penceresini açık tutun.

Tip

Alternatif yükleme yöntemleri de dahil olmak üzere Azurite hakkında daha fazla bilgi için bkz. Yerel Azure Depolama geliştirmesi için Azurite öykünücüsü kullanma.

Dayanıklı Görev Zamanlayıcı Emülatörünü Başlat

DTS öykünücüsü, aracı durumunu ve orkestrasyonlarını yönetmek için dayanıklı bir arka uç sağlar. Konuşma geçmişini depolar ve yeniden başlatmalar boyunca servis ayarlarınızın durumunun kalıcı olmasını sağlar. Ayrıca kalıcı düzenlemeleri ve aracıları tetikler. Bunu ayrı bir yeni terminal penceresinde çalıştırmanız ve dayanıklı yazılım bileşeninizi geliştirip test ederken çalışır halde tutmanız gerekir.

  1. Yeni bir terminal penceresi açın ve DTS emülatörü için Docker görüntüsünü çekin.

    docker pull mcr.microsoft.com/dts/dts-emulator:latest

  2. DTS öykünücüsİnİ çalıştırın:

    docker run -p 8080:8080 -p 8082:8082 mcr.microsoft.com/dts/dts-emulator:latest

    Bu komut öykünücüyü başlatır ve şunu açar:

    • Bağlantı noktası 8080: Dayanıklı Görev Zamanlayıcı için gRPC uç noktası (İşlevler uygulamanız tarafından kullanılır)
    • Bağlantı noktası 8082: Yönetim panosu

  3. Kontrol paneli http://localhost:8082 adresinde erişilebilir olacaktır.

Dayanıklı yazılım ajanınızı geliştirirken ve test ederken bu terminal penceresini açık tutun.

Tip

Birden çok görev hub'ı yapılandırma ve panoya erişme dahil olmak üzere DTS öykünücüsü hakkında daha fazla bilgi edinmek için bkz. Dayanıklı Görev Zamanlayıcı ile geliştirme.

İşlev uygulamasını çalıştırma

Artık dayanıklı aracı kullanarak Azure Functions uygulamanızı çalıştırmaya hazırsınız.

  1. Yeni bir terminal penceresinde (hem Azurite hem de DTS öykünücüsün ayrı pencerelerde çalışmasını sağlayarak), proje dizininize gidin.

  2. Azure İşlevleri çalışma zamanını başlatın:

    func start

  3. Aracınızın HTTP uç noktaları da dahil olmak üzere işlev uygulamanızın çalıştığını gösteren bir çıktı görmeniz gerekir:

    Functions:
     http-MyDurableAgent: [POST] http://localhost:7071/api/agents/MyDurableAgent/run
     dafx-MyDurableAgent: entityTrigger

Bu uç noktalar konuşma durumunu otomatik olarak yönetir. İş parçacığı nesnelerini kendiniz oluşturmanız veya yönetmeniz gerekmez.

Ajanı yerel olarak test edin

Artık HTTP isteklerini kullanarak dayanıklı aracınızla etkileşim kurabilirsiniz. Aracı, birden çok istekte konuşma durumunu korur ve çok aşamalı konuşmaları etkinleştirir.

Yeni bir görüşme başlatma

Yeni bir konu oluşturun ve ilk iletinizi gönderin.

curl -i -X POST http://localhost:7071/api/agents/MyDurableAgent/run \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Örnek yanıt (üst bilgide x-ms-thread-id iş parçacığı kimliğinin bulunduğuna dikkat edin):

HTTP/1.1 200 OK
Content-Type: text/plain
x-ms-thread-id: @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d
Content-Length: 189

Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity and readability, JavaScript powers web interactivity, and Java is widely used in enterprise applications.

Sonraki istek için x-ms-thread-id başlığından (örn. @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d) iş parçacığı kimliğini kaydedin.

Konuşmaya devam et

İş parçacığı kimliğini sorgu parametresi olarak ekleyerek aynı iş parçacığına bir izleme iletisi gönderin:

curl -X POST "http://localhost:7071/api/agents/MyDurableAgent/run?thread_id=@dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d" \
  -H "Content-Type: text/plain" \
  -d "Which one is best for beginners?"

Önceki yanıtın @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d başlığındaki gerçek iş parçacığı kimliği ile x-ms-thread-id'ı değiştirin.

Örnek yanıt:

Python is often considered the best choice for beginners among those three. Its clean syntax reads almost like English, making it easier to learn programming concepts without getting overwhelmed by complex syntax. It's also versatile and widely used in education.

Ajansın, daha önceki iletiden (üç programlama dili) bağlamı yeniden belirtmenize gerek kalmadan hatırladığını fark edin. Konuşma durumu Dayanıklı Görev Zamanlayıcı tarafından sabit bir şekilde depolandığından, işlev uygulamasını yeniden başlatsanız veya konuşma farklı bir örnek tarafından sürdürülse bile bu geçmiş kalıcı olur.

Dayanıklı Görev Zamanlayıcı panosuyla izleme

Dayanıklı Görev Zamanlayıcı, dayanıklı görevlerinizi izlemek ve hatalarını ayıklamak için yerleşik bir kontrol paneli sağlar. Pano aracı işlemleri, konuşma geçmişi ve yürütme akışı hakkında ayrıntılı görünürlük sağlar.

Panoya erişme

  1. Yerel DTS öykünücünüzün kontrol panelini web tarayıcınızda açın.

  2. Ayrıntılarını görüntülemek için listeden varsayılan görev hub'ını seçin.

  3. Sağ üst köşedeki dişli simgesini seçerek ayarları açın ve Önizleme Özellikleri altındaki Aracı sayfalarını etkinleştir seçeneğinin seçili olduğundan emin olun.

Temsilci konuşmalarını keşfet

  1. Panoda Aracılar sekmesine gidin.

  2. Listeden dayanıklı ajan iş parçacığınızı (örneğin, mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) seçin.

    Tüm iletilerin ve yanıtların yer aldığı konuşma geçmişinin tamamı da dahil olmak üzere aracı iş parçacığının ayrıntılı bir görünümünü görürsünüz.

    Bir ajan iş parçacığının konuşma geçmişini gösteren Çalışma Performansı Görev Zamanlayıcı panosunun ekran görüntüsü.

Pano, konuşmanın akışını anlamanıza yardımcı olacak bir zaman çizelgesi görünümü sağlar. Önemli bilgiler şunlardır:

  • Her etkileşim için zaman damgaları ve süre
  • İstem ve yanıt içeriği
  • Kullanılan belirteç sayısı

Tip

DTS panosu gerçek zamanlı güncelleştirmeler sağlar, böylece HTTP uç noktaları aracılığıyla aracınızla etkileşim kurarken aracının davranışını izleyebilirsiniz.

Azure’a dağıtın

Dayanıklı etkeninizi yerel olarak test ettiğinize göre, Azure'a dağıtmaya başlayın.

  1. Uygulamayı dağıtma:

    azd deploy

    Bu komut uygulamanızı paketler ve sağlama sırasında oluşturulan Azure İşlevleri uygulamasına dağıtır.

  2. Dağıtımın tamamlanmasını bekleyin. Çıkış, aracınızın Azure'da çalışmakta olduğunu onaylayacaktır.

Dağıtılan aracıyı test edin

Dağıtımdan sonra Azure'da çalışan aracınızı test edin.

İşlev anahtarını alma

Azure İşlevleri, üretimde HTTP ile tetiklenen işlevler için bir API anahtarı gerektirir:

API_KEY=`az functionapp function keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --function-name http-MyDurableAgent --query default -o tsv`

Azure'da yeni bir konuşma başlatma

Yeni bir iş parçacığı oluşturun ve atanmış ajanınıza ilk mesajınızı gönderin.

curl -i -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" \
  -H "Content-Type: text/plain" \
  -d "What are three popular programming languages?"

Yanıt üstbilgi alanında x-ms-thread-id döndürülen iş parçacığı kimliğini not edin.

Azure'da konuşmaya devam edin

Aynı yazışmada bir izleme iletisi gönderin. değerini önceki yanıttan alınan iş parçacığı kimliğiyle değiştirin <thread-id> :

THREAD_ID="<thread-id>"
curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY&thread_id=$THREAD_ID" \
  -H "Content-Type: text/plain" \
  -d "Which is easiest to learn?"

Aracı, yerel olarak yaptığı gibi Azure'da da konuşma bağlamını korur ve ajan durumunun dayanıklılığını gösterir.

Dağıtılan aracı denetle

Dağıtılan aracınızı Azure'daki Dayanıklı Görev Zamanlayıcı panosunu kullanarak izleyebilirsiniz.

  1. Dayanıklı Görev Zamanlayıcı örneğinizin adını alın:

    azd env get-value DTS_NAME

  2. Azure portalını açın ve önceki adımdaki Dayanıklı Görev Zamanlayıcı adını arayın.

  3. Dayanıklı Görev Zamanlayıcı kaynağının genel bakış sekmesinde listeden varsayılan görev hub'ını seçin.

  4. İzleme panosunu açmak için görev hub'ı sayfasının üst kısmındaki Panoyu Aç'ı seçin.

  5. Yerel emülatörde yaptığınız gibi temsilcinizin konuşmalarını görüntüleyin.

Azure tarafından barındırılan pano, yerel öykünücüyle aynı hata ayıklama ve izleme özelliklerini sağlayarak konuşma geçmişini incelemenize, araç çağrılarını izlemenize ve üretim ortamınızdaki performansı analiz etmeye olanak tanır.

Öğretici: Dayanıklı aracıları düzenleme

Bu öğreticide, fan-out/fan-in desenini kullanarak birden çok dayanıklı yapay zeka aracısını düzenleme gösterilmektedir. Bir kullanıcının sorusunu işleyen ve ardından yanıtı eşzamanlı olarak birden çok dile çeviren çok aracılı bir sistem oluşturmak için önceki öğreticideki dayanıklı aracıyı genişleteceksiniz.

Düzenleme düzenini anlama

Oluşturabileceğiniz düzenleme şu akışı izler:

  1. Kullanıcı girişi - Kullanıcıdan gelen bir soru veya ileti
  2. Ana temsilci - İlk öğretiden alınan MyDurableAgent, soruyu işler
  3. Fan-out - Ana aracının yanıtı aynı anda her iki çeviri aracısına da gönderilir
  4. Çeviri aracıları - İki özel aracı yanıtı çevirir (Fransızca ve İspanyolca)
  5. Fan-in - Sonuçlar, özgün yanıt ve çevirilerle tek bir JSON yanıtı halinde toplanır

Bu düzen eşzamanlı işlemeye olanak sağlayarak sıralı çeviriye kıyasla toplam yanıt süresini kısaltır.

Sistemi başlatırken aracıları kaydetme

Ajanları kalıcı orkestrasyonlarda doğru bir şekilde kullanmak için, uygulama başlatıldığında kaydedin. Bunlar orkestrasyon yürütmeleri boyunca kullanılabilir.

Çeviri aracılarını mevcut Program.cs ile birlikte kaydedecek şekilde MyDurableAgent'inizi güncelleyin.

using System;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Hosting.AzureFunctions;
using Microsoft.Azure.Functions.Worker.Builder;
using Microsoft.Extensions.Hosting;
using OpenAI;
using OpenAI.Chat;

// Get the Azure OpenAI configuration
string endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT")
    ?? throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
string deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT")
    ?? "gpt-4o-mini";

// Create the Azure OpenAI client
AzureOpenAIClient client = new(new Uri(endpoint), new DefaultAzureCredential());
ChatClient chatClient = client.GetChatClient(deploymentName);

// Create the main agent from the first tutorial
AIAgent mainAgent = chatClient.AsAIAgent(
    instructions: "You are a helpful assistant that can answer questions and provide information.",
    name: "MyDurableAgent");

// Create translation agents
AIAgent frenchAgent = chatClient.AsAIAgent(
    instructions: "You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name: "FrenchTranslator");

AIAgent spanishAgent = chatClient.AsAIAgent(
    instructions: "You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name: "SpanishTranslator");

// Build and configure the Functions host
using IHost app = FunctionsApplication
    .CreateBuilder(args)
    .ConfigureFunctionsWebApplication()
    .ConfigureDurableAgents(options =>
    {
        // Register all agents for use in orchestrations and HTTP endpoints
        options.AddAIAgent(mainAgent);
        options.AddAIAgent(frenchAgent);
        options.AddAIAgent(spanishAgent);
    })
    .Build();

app.Run();

Çeviri aracılarını mevcut function_app.py ile birlikte kaydedecek şekilde MyDurableAgent'inizi güncelleyin.

import os
from azure.identity import DefaultAzureCredential
from agent_framework.azure import AzureOpenAIChatClient, AgentFunctionApp

# Get the Azure OpenAI configuration
endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
if not endpoint:
    raise ValueError("AZURE_OPENAI_ENDPOINT is not set.")
deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")

# Create the Azure OpenAI client
chat_client = AzureOpenAIChatClient(
    endpoint=endpoint,
    deployment_name=deployment_name,
    credential=DefaultAzureCredential()
)

# Create the main agent from the first tutorial
main_agent = chat_client.as_agent(
    instructions="You are a helpful assistant that can answer questions and provide information.",
    name="MyDurableAgent"
)

# Create translation agents
french_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to French. Return only the translation, no explanations.",
    name="FrenchTranslator"
)

spanish_agent = chat_client.as_agent(
    instructions="You are a translator. Translate the following text to Spanish. Return only the translation, no explanations.",
    name="SpanishTranslator"
)

# Create the function app and register all agents
app = AgentFunctionApp(agents=[main_agent, french_agent, spanish_agent])

Orkestrasyon işlevi oluşturma

Düzenleme işlevi, iş akışını birden çok aracı arasında koordine eder. Dayanıklı bağlamdan kayıtlı aracıları alır ve yürütmelerini düzenler, önce ana aracıyı çağırır, ardından çeviri aracılarını eşzamanlı olarak paralel olarak çalıştırır.

Proje dizininizde adlı AgentOrchestration.cs yeni bir dosya oluşturun:

using System.Collections.Generic;
using System.Threading.Tasks;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.DurableTask;
using Microsoft.Azure.Functions.Worker;
using Microsoft.DurableTask;

namespace MyDurableAgent;

public static class AgentOrchestration
{
    // Define a strongly-typed response structure for agent outputs
    public sealed record TextResponse(string Text);

    [Function("agent_orchestration_workflow")]
    public static async Task<Dictionary<string, string>> AgentOrchestrationWorkflow(
        [OrchestrationTrigger] TaskOrchestrationContext context)
    {
        var input = context.GetInput<string>() ?? throw new ArgumentNullException(nameof(context), "Input cannot be null");

        // Step 1: Get the main agent's response
        DurableAIAgent mainAgent = context.GetAgent("MyDurableAgent");
        AgentResponse<TextResponse> mainResponse = await mainAgent.RunAsync<TextResponse>(input);
        string agentResponse = mainResponse.Result.Text;

        // Step 2: Fan out - get the translation agents and run them concurrently
        DurableAIAgent frenchAgent = context.GetAgent("FrenchTranslator");
        DurableAIAgent spanishAgent = context.GetAgent("SpanishTranslator");

        Task<AgentResponse<TextResponse>> frenchTask = frenchAgent.RunAsync<TextResponse>(agentResponse);
        Task<AgentResponse<TextResponse>> spanishTask = spanishAgent.RunAsync<TextResponse>(agentResponse);

        // Step 3: Wait for both translation tasks to complete (fan-in)
        await Task.WhenAll(frenchTask, spanishTask);

        // Get the translation results
        TextResponse frenchResponse = (await frenchTask).Result;
        TextResponse spanishResponse = (await spanishTask).Result;

        // Step 4: Combine results into a dictionary
        var result = new Dictionary<string, string>
        {
            ["original"] = agentResponse,
            ["french"] = frenchResponse.Text,
            ["spanish"] = spanishResponse.Text
        };

        return result;
    }
}

Orkestrasyon işlevini function_app.py dosyanıza ekleyin.

import azure.durable_functions as df

@app.orchestration_trigger(context_name="context")
def agent_orchestration_workflow(context: df.DurableOrchestrationContext):
    """
    Orchestration function that coordinates multiple agents.
    Returns a dictionary with the original response and translations.
    """
    input_text = context.get_input()

    # Step 1: Get the main agent's response
    main_agent = app.get_agent(context, "MyDurableAgent")
    main_response = yield main_agent.run(input_text)
    agent_response = main_response.text

    # Step 2: Fan out - get the translation agents and run them concurrently
    french_agent = app.get_agent(context, "FrenchTranslator")
    spanish_agent = app.get_agent(context, "SpanishTranslator")

    parallel_tasks = [
        french_agent.run(agent_response),
        spanish_agent.run(agent_response)
    ]

    # Step 3: Wait for both translation tasks to complete (fan-in)
    translations = yield context.task_all(parallel_tasks) # type: ignore

    # Step 4: Combine results into a dictionary
    result = {
        "original": agent_response,
        "french": translations[0].text,
        "spanish": translations[1].text
    }

    return result

Düzenlemeyi test edin

İlk öğreticideki yerel geliştirme bağımlılıklarınızın hala çalıştığından emin olun:

  • Bir terminal penceresinde Azurite
  • Başka bir terminal penceresinde Dayanıklı Görev Zamanlayıcı öykünücüsü

Yerel geliştirme bağımlılıklarınız çalışırken şunları yapabilirsiniz:

  1. Azure İşlevleri uygulamanızı yeni bir terminal penceresinde başlatın:

    func start

  2. Dayanıklı İşlevler uzantısı, düzenlemeleri yönetmek için otomatik olarak yerleşik HTTP uç noktaları oluşturur. Yerleşik API'yi kullanarak düzenlemeyi başlatın:

    curl -X POST http://localhost:7071/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'

  1. Yanıt, düzenleme örneğini yönetmek için URL'leri içerir:

    {
  "id": "abc123def456",
  "statusQueryGetUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456",
  "sendEventPostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/raiseEvent/{eventName}",
  "terminatePostUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456/terminate",
  "purgeHistoryDeleteUri": "http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456"
}

  2. Orkestrasyon durumunu sorgulamak için statusQueryGetUri öğesini kullanın (gerçek örnek kimliğinizi abc123def456 ile değiştirin):

    curl http://localhost:7071/runtime/webhooks/durabletask/instances/abc123def456

  1. runtimeStatus Completed olana kadar durumu uç noktasını yokla. Tamamlandığında, ana aracının yanıtını ve çevirilerini içeren orkestrasyon çıktısını görürsünüz.

    {
  "name": "agent_orchestration_workflow",
  "instanceId": "abc123def456",
  "runtimeStatus": "Completed",
  "output": {
    "original": "Three popular programming languages are Python, JavaScript, and Java. Python is known for its simplicity...",
    "french": "Trois langages de programmation populaires sont Python, JavaScript et Java. Python est connu pour sa simplicité...",
    "spanish": "Tres lenguajes de programación populares son Python, JavaScript y Java. Python es conocido por su simplicidad..."
  }
}

Panodaki orkestrasyonu izleyin

Dayanıklı Görev Zamanlayıcı panosu düzenlemenize görünürlük sağlar:

  1. Tarayıcınızda açın http://localhost:8082 .

  2. "Varsayılan" görev hub'ını seçin.

  3. "Orchestrations" sekmesini seçin.

  4. Orkestrasyon örneğinizi listede bulun.

  5. Görmek için örneği seçin:

    • Düzenleme zaman çizelgesi
    • Ana aracı yürütmesi ve ardından eşzamanlı çeviri aracıları
    • Her bir aracı çalıştırma (önce MyDurableAgent, ardından Fransızca ve İspanyolca çeviri ajanları)
    • Görselleştirilen fan-out ve fan-in kalıpları
    • Her adım için zamanlama ve süre

Düzenlemeyi Azure'a dağıtma

Azure Geliştirici CLI'sını kullanarak güncelleştirilmiş uygulamayı dağıtma:

azd deploy

Bu, güncelleştirilmiş kodunuzu yeni düzenleme işlevi ve ek aracılarla ilk öğreticide oluşturulan Azure İşlevleri uygulamasına dağıtır.

Dağıtılan orkestrasyonu test edin

Dağıtımdan sonra Azure'da çalışan düzenlemenizi test edin.

  1. Dayanıklı uzantı için sistem anahtarını alın:

    SYSTEM_KEY=$(az functionapp keys list --name $(azd env get-value AZURE_FUNCTION_NAME) --resource-group $(azd env get-value AZURE_RESOURCE_GROUP) --query "systemKeys.durabletask_extension" -o tsv)

  1. Yerleşik API'yi kullanarak düzenlemeyi başlatın:

    curl -X POST "https://$(azd env get-value AZURE_FUNCTION_NAME).azurewebsites.net/runtime/webhooks/durabletask/orchestrators/agent_orchestration_workflow?code=$SYSTEM_KEY" \
  -H "Content-Type: application/json" \
  -d '"\"What are three popular programming languages?\""'
  1. Yanıttan statusQueryGetUri öğesini kullanarak tamamlanıp tamamlanmadığını kontrol edin ve çeviriler ile sonuçları görüntüleyin.

Sonraki Adımlar

uç noktalarıOpenAI-Compatible

Ek kaynaklar:

  • Last updated on