Dayanıklı Uzantı

Microsoft Agent Framework için Dayanıklı Uzantı aracılara, çok aracılı düzenlemelere ve Microsoft Agent Framework iş akışlarına dayanıklı yürütme getirir. Aracı oturumlarını, denetim noktası düzenlemesini ve iş akışı ilerleme durumunu kalıcı hale getirmek, hatalardan kurtarmak ve çekirdek aracı mantığınızı değiştirmeden dağıtılmış konaklar arasında çalışmayı ölçeklendirmek için bunu kullanabilirsiniz.

Uzantı C# ve Python iki barındırma modeli destekler:

• Azure İşlevleri programlama modeliyle yönetilen, sunucusuz barındırma için Azure İşlevleri.
• Kendi çalışan işleminizde, hizmetinizde, kapsayıcınızda, Kubernetes ortamınızda veya mevcut uygulama altyapınızda dayanıklı aracıları ve iş akışlarını çalıştırmak için kendi işleminizi getirin/ şirket içinde barındırılan.

Genel bakış

Dayanıklı aracılar, Aracı Çerçevesi programlama modelini Dayanıklı Görev Zamanlayıcı gibi Dayanıklı Görev altyapısıyla birleştirerek aşağıdaki aracıları oluşturur:

• İstekler ve çalışan yürütmeleri arasında durumu otomatik olarak kalıcı hale döndürme
• Konuşma bağlamı kaybetmeden veya tamamlanan çalışmayı yinelemeden hatalardan sonra devam et
• İsteğe bağlı olarak dağıtılmış, durum bilgisi olmayan çalışanlar arasında ölçeklendirme
• Çok aracılı iş akışlarını güvenilir yürütme garantileriyle düzenleme
• Graf tabanlı iş akışı modeliyle oluşturulmuş Checkpoint Agent Framework iş akışları
• beklerken işlem veya model belirteçleri kullanmadan insan girişi veya dış olaylar için duraklatma
• Redis gibi güvenilir bir akış aracısı ile yapılandırıldığında yanıtları güvenilir bir şekilde akışla aktar
• Oturum yaşam döngüsünü, oturum yaşam süresi (TTL) temizleme ve pano tabanlı izleme ile yönetme

Dayanıklı ajanlar ne zaman kullanılmalıdır?

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

• Kalıcı konuşma durumu: Aracı oturumları işlem kilitlenmelerinden, yeniden başlatmalardan ve ölçeği genişletme olaylarından devam eder
• 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ı düzenleme: Tetikleyiciler, kuyruklar, web kancaları, zamanlayıcılar veya mevcut uygulama olaylarıyla 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
• Durable Agent Framework iş akışları: Graf tabanlı Microsoft Agent Framework iş akışlarını dayanıklı hale getirerek her adımın denetlenip sürdürülebilmesini sağlayın
• Uzun süreli oturumlar: Boşta kalan oturumları otomatik olarak kaldırmak için oturum yaşam süresi (TTL) temizlemesini kullanırken yararlı konuşmaları kullanılabilir durumda tutun
• Güvenilir gerçek zamanlı yanıtlar: Teslim garantileri ile gerçek zamanlı UX gerektiren uygulamalar için belirteç çıkışını dayanıklı bir şekilde akışla aktarın

Bu barındırma yaklaşımı, çalışan konaklarını dağıtmanıza veya yönetmenize gerek kalmadan tam olarak yönetilen altyapı sağlayan yönetilen hizmet tabanlı aracı barındırmadan (Foundry Aracı Hizmeti gibi) farklıdır. Dayanıklı aracılar, dayanıklı durum yönetimiyle birlikte kod öncelikli dağıtım esnekliğine ihtiyacınız olduğunda idealdir.

Barındırma modeli seçme

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. Şirket içinde barındırılan senaryolarda kendi ana bilgisayarınız işlem ömrünü, ölçeklendirmeyi, ağı ve dağıtımı denetler.

Başlangıç Yapmak

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

dotnet add package Microsoft.Agents.AI.DurableTask --prerelease
dotnet add package Microsoft.DurableTask.Client.AzureManaged
dotnet add package Microsoft.DurableTask.Worker.AzureManaged
dotnet add package Microsoft.Extensions.Hosting

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

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

Azure İşlevleri barındırma

Dayanıklı Uzantı ile yerleşik HTTP uç noktaları ve düzenleme tabanlı çağırma ile Azure İşlevleri 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.

Azure İşlevleri'de dayanıklı bir aracı yapılandırdığınızda uzantı, 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 altyapıyı yönetir. Azure İşlevleri barındırma tümleştirmesi ayrıca ileti göndermek, durumu denetlemek ve oturumları yönetmek için oluşturulan REST API'ler gibi İşlevlere özgü kolaylıkların yanı sıra tetikleyici tutkalı yazmadan MCP sunucuları olarak aracı barındırmak için MCP sunucu tetikleyicisi gibi tetikleyiciler sağlar.

using System;
using Azure.AI.Projects;
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 AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        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 AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
from azure.identity import DefaultAzureCredential

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

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    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])

Kendi işlemlerinizi getirin / şirket içinde barındırılan barındırma

Dayanıklı Uzantı özelliklerini Azure İşlevleri programlama modeli kullanmadan kullanmak istediğinizde kendi işlem barındırmanızı getirin. Bu modelde, işleminiz bir Dayanıklı Görev çalışanı başlatır, dayanıklı aracıları veya iş akışlarını kaydeder ve Dayanıklı Görev Zamanlayıcı arka ucuna bağlanır. İstemci kodu aynı işlemde veya ayrı bir hizmette çalıştırılabilir.

Şirket içinde barındırılan çalışanlar, Azure İşlevleri barındırma ile aynı temel Dayanıklı Uzantı özelliklerini kullanır: denetim noktası oluşturma ve sürdürme, belirleyici aracı düzenleme, dayanıklı Agent Framework iş akışları, döngüde insan beklemeleri, güvenilir akış, boşta oturum temizleme, pano görünürlüğü ve durum bilgisi olmayan çalışan örnekleri arasında dağıtılmış yürütme. Konağınız kendi API'lerini, yaşam döngüsü yönetimini, ağ, kimlik doğrulamasını ve dağıtım modelini kullanıma çıkarmakla sorumludur.

string connectionString = Environment.GetEnvironmentVariable("DURABLE_TASK_SCHEDULER_CONNECTION_STRING")
    ?? "Endpoint=http://localhost:8080;TaskHub=default;Authentication=None";

IHost host = Host.CreateDefaultBuilder(args)
    .ConfigureServices(services =>
    {
        services.ConfigureDurableAgents(
            options => options.AddAIAgent(agent),
            workerBuilder: builder => builder.UseDurableTaskScheduler(connectionString),
            clientBuilder: builder => builder.UseDurableTaskScheduler(connectionString));
    })
    .Build();

await host.StartAsync();

from agent_framework.azure import DurableAIAgentWorker
from durabletask.azuremanaged.worker import DurableTaskSchedulerWorker

worker = DurableTaskSchedulerWorker(
    host_address="http://localhost:8080",
    secure_channel=False,
    taskhub="default",
)

agent_worker = DurableAIAgentWorker(worker)
agent_worker.add_agent(agent)

worker.start()

Dayanıklı Agent Framework iş akışları

Dayanıklılık, dayanıklı düzenlemelerle sınırlı değildir. Graf tabanlı iş akışı modeliyle oluşturulan Microsoft Agent Framework iş akışları da dayanıklı hale getirilebilir. Dayanıklı Uzantı denetim noktaları iş akışı yürütmesini sağlar, bu nedenle tamamlanan yürütücü ve aracı adımları bir işlem yeniden başlatma veya hatadan sonra yinelenmez.

Kod tabanlı dallanma, zamanlayıcılar, etkinlikler ve dış olaylarla kesin koordinasyon istiyorsanız dayanıklı düzenleme kullanın. Türü belirtilmiş yönlendirme, yayma/fan-in, koşullu kenarlar, iş akışı olayları, paylaşılan durum, alt iş akışları veya döngüde insan isteği bağlantı noktaları olan yürütücülerin ve aracıların bildirim temelli grafiğini istediğinizde dayanıklı Agent Framework iş akışlarını kullanın.

Samples

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ısı gibi Dayanıklı Görev altyapısı 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, bir konak işlemi yeniden başlatıldığında veya çalışma farklı bir çalışan örneğinde devam etse bile konuşmanın kaldığı yerden sorunsuz bir şekilde devam etmesini sağlar.

Etkin kullanım sırasında dayanıklı süreklilik gerektiren ancak boşta konuşmaları otomatik olarak temizlemesi gereken iş yükleri için oturum yaşam süresi (TTL) temizlemesini kullanın. TTL tabanlı temizleme, etkin oturum durumunu korurken kullanılmayan oturumların ve konuşma geçmişinin süresiz olarak birikmesini önler.

Aşağıdaki Azure İşlevleri ö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. Şirket içinde barındırılan uygulamalarda, kendi işleminizdeki veya hizmetinizdeki Dayanıklı Görev istemci API'lerini kullanın.

# 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.

Güvenilir akış

Dayanıklı Uzantı, dayanıklı teslim garantileri ile gerçek zamanlı belirteç teslimi gerektiren uygulamalar için güvenilir akışı destekler. Akış, her iki barındırma modelinde de çekirdek uzantıyla kullanılabilir, ancak dağıtılmış konakların Redis gibi güvenilir bir akış aracısı olması gerekir, bu nedenle belirteç akışları işlem yeniden başlatmaları, yeniden bağlantılar veya çalışan değişiklikleri arasında tutarlı bir şekilde teslim edilebilir.

Kullanıcı deneyimi artımlı yanıtlara bağlı olduğunda ancak iş yükünün yine de dayanıklı yürütme semantiğine ihtiyacı olduğunda güvenilir akış kullanın. Çalıştırılabilir örnekler için güvenilir akış desenlerini içeren Python Dayanıklı Görev örnekleri bölümüne bakın.

Belirlenimci çok aracılı düzenleme

Dayanıklı Uzantı, Dayanıklı Görev düzenlemelerini kullanarak birden çok aracıyı koordine eden belirleyici iş akışları oluşturulmasını destekler. Azure İşlevleri'de bunlar Dayanıklı İşlevler düzenlemelerini kullanır; kendi işleminizi getirin konaklarında, yapılandırdığınız Dayanıklı Görev çalışanı ve istemcisi aracılığıyla çalışır.

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.

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

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,
        options={"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,
        options={"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ı Görev istemci SDK'sını veya Azure İşlevleri Dayanıklı uzantı uç noktaları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 uygulamalar diğer depolama arka uçlarını (Azure Depolama gibi) kullanabilir, ancak DTS özellikle dayanıklı iş yükleri için iyileştirilmiştir ve üstün performans ve izleme özellikleri sağlar. Şirket içinde barındırılan çalışanlar dayanıklı zamanlama, durum ve pano görünürlüğü için DTS de kullanır.

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

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

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: Azure İşlevleri ile dayanıklı aracı oluşturma ve çalıştırma

Bu öğreticide Dayanıklı Uzantı için Azure İşlevleri barındırma modelini kullanarak dayanıklı bir yapay zeka aracısını nasıl oluşturacağınız ve çalıştıracağınız 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. Şirket içinde barındırılan aracılar için örneklere bakın.

Prerequisites

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

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.

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.

using Azure.AI.Projects;
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") 
    ?? 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 AIProjectClient(new Uri(endpoint), new DefaultAzureCredential())
    .AsAIAgent(
        model: deploymentName,
        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();

import os
from agent_framework.azure import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient
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_CHAT_COMPLETION_MODEL", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create an AI agent following the standard Microsoft Agent Framework pattern
agent = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    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])

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:

   • Bash
   • PowerShell

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

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.

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.

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

Artık dayanıklı aracı kullanarak Azure İşlevleri 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?"

$response = Invoke-WebRequest -Uri "http://localhost:7071/api/agents/MyDurableAgent/run" `
  -Method POST `
  -Headers @{"Content-Type"="text/plain"} `
  -Body "What are three popular programming languages?"
$response.Headers
$response.Content

Ö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?"

$threadId = "@dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d"
Invoke-RestMethod -Uri "http://localhost:7071/api/agents/MyDurableAgent/run?thread_id=$threadId" `
  -Method POST `
  -Headers @{"Content-Type"="text/plain"} `
  -Body "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.

   

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ı

Azure'a dağıtım yap

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 ajanı 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`

$functionName = azd env get-value AZURE_FUNCTION_NAME
$resourceGroup = azd env get-value AZURE_RESOURCE_GROUP
$API_KEY = az functionapp function keys list --name $functionName --resource-group $resourceGroup --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?"

$functionName = azd env get-value AZURE_FUNCTION_NAME
$response = Invoke-WebRequest -Uri "https://$functionName.azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY" `
  -Method POST `
  -Headers @{"Content-Type"="text/plain"} `
  -Body "What are three popular programming languages?"
$response.Headers
$response.Content

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?"

$THREAD_ID = "<thread-id>"
$functionName = azd env get-value AZURE_FUNCTION_NAME
Invoke-RestMethod -Uri "https://$functionName.azurewebsites.net/api/agents/MyDurableAgent/run?code=$API_KEY&thread_id=$THREAD_ID" `
  -Method POST `
  -Headers @{"Content-Type"="text/plain"} `
  -Body "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ı Azure İşlevleri ile düzenleme

Bu öğreticide, Azure İşlevleri barındırma modelini ve 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. Şirket içinde barındırılan düzenleme örnekleri için örneklere bakın.

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.

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

// 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 Microsoft Foundry client
AIProjectClient client = new(new Uri(endpoint), new DefaultAzureCredential());

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

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

AIAgent spanishAgent = client.AsAIAgent(
    model: deploymentName,
    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();

import os
from azure.identity import DefaultAzureCredential
from agent_framework.azure import AgentFunctionApp
from agent_framework.openai import OpenAIChatCompletionClient

# 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_CHAT_COMPLETION_MODEL", "gpt-4o-mini")
api_version = os.getenv("AZURE_OPENAI_API_VERSION")

# Create the Azure OpenAI client
chat_client = OpenAIChatCompletionClient(
    azure_endpoint=endpoint,
    model=deployment_name,
    api_version=api_version,
    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.

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

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:

   • Bash
   • PowerShell

   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):

   • Bash
   • PowerShell

   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 http://localhost:8082 açın.

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:

   • Bash
   • PowerShell

   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:

   • Bash
   • PowerShell

   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

Ek kaynaklar:

• Microsoft Agent Framework için Durable Görev uzantısı
• Dayanıklı Görev Zamanlayıcıya Genel Bakış
• Dayanıklı Görev Zamanlayıcı Panosu
• Azure İşlevleri Esnek Tüketim Planı
• Dayanıklı İşlevler desenleri ve kavramları