Ekstensi Tahan Lama

Durable Extension for Microsoft Agent Framework menghadirkan eksekusi yang tahan lama bagi agen, orkestrasi multi-agen, dan alur kerja Microsoft Agent Framework. Anda dapat menggunakannya untuk mempertahankan sesi agen, orkestrasi titik pemeriksaan, dan kemajuan alur kerja, memulihkan dari kegagalan, dan menskalakan pekerjaan di seluruh host terdistribusi tanpa mengubah logika agen inti Anda.

Ekstensi ini mendukung dua model hosting di C# dan Python:

• Azure Functions untuk hosting terkelola tanpa server dengan model pemrograman Azure Functions.
• Bring-your-own-compute / self-hosted untuk menjalankan agen dan alur kerja yang tahan lama dalam proses pekerja, layanan, kontainer, lingkungan Kubernetes Anda sendiri, atau infrastruktur aplikasi yang ada.

Overview

Agen tahan lama menggabungkan model pemrograman Agent Framework dengan infrastruktur Durable Task, seperti Durable Task Scheduler, untuk membuat agen yang:

• Mempertahankan status secara otomatis di seluruh permintaan dan eksekusi pekerja
• Lanjutkan setelah kegagalan tanpa kehilangan konteks percakapan atau mengulangi pekerjaan yang selesai
• Menskalakan di seluruh pekerja tanpa status terdistribusi berdasarkan permintaan
• Mengatur alur kerja multi-agen dengan jaminan eksekusi yang andal
• Alur kerja Kerangka Kerja Agen Titik Pemeriksaan yang dibangun dengan model alur kerja berbasis grafik
• Jeda untuk input manusia atau peristiwa eksternal tanpa menggunakan token komputasi atau model saat menunggu
• Respons streaming andal saat dikonfigurasi dengan broker stream yang andal, seperti Redis
• Mengelola siklus hidup sesi dengan pembersihan sesi time-to-live (TTL) dan pemantauan berbasis dasbor

Kapan menggunakan agen tahan lama

Pilih agen tahan lama saat Anda membutuhkan:

• Status percakapan persisten: Sesi agen bertahan dari crash proses, mulai ulang, dan peristiwa peluasan skala
• Orkestrasi kompleks: Mengoordinasikan beberapa agen dengan alur kerja deterministik dan andal yang dapat berjalan selama ber hari atau minggu
• Orkestrasi berbasis peristiwa: Integrasikan dengan pemicu, antrean, webhook, timer, atau peristiwa aplikasi yang ada
• Status percakapan otomatis: Riwayat percakapan agen dikelola dan dipertahankan secara otomatis tanpa memerlukan penanganan status eksplisit dalam kode Anda
• Jalan kerja Kerangka Kerja Agen yang Dapat Diatasi: Membuat alur kerja Kerangka Kerja Agen Microsoft berbasis grafik tahan lama sehingga setiap langkah dapat di-checkpoint dan dilanjutkan
• Sesi berumur panjang: Jaga agar percakapan yang berguna tetap tersedia saat menggunakan pembersihan time-to-live (TTL) sesi untuk menghapus sesi diam secara otomatis
• Respons real-time yang andal: Output token aliran durably untuk aplikasi yang membutuhkan UX real time dengan jaminan pengiriman

Pendekatan hosting ini berbeda dari hosting agen berbasis layanan terkelola (seperti Foundry Agent Service), yang menyediakan infrastruktur yang dikelola sepenuhnya tanpa mengharuskan Anda untuk menyebarkan atau mengelola host pekerja. Agen tahan lama sangat ideal ketika Anda membutuhkan fleksibilitas penyebaran code-first yang dikombinasikan dengan manajemen status tahan lama.

Pilih model hosting

Saat dihosting dalam paket hosting Konsumsi Azure Functions Flex , agen dapat menskalakan ke ribuan instans atau ke nol instans saat tidak digunakan, memungkinkan Anda membayar hanya untuk komputasi yang Anda butuhkan. Dalam skenario yang dihost sendiri, host Anda sendiri mengontrol masa pakai proses, penskalaan, jaringan, dan penyebaran.

Memulai Langkah Pertama

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

hosting Azure Functions

Dengan Ekstensi Tahan Lama, Anda dapat menyebarkan dan menghosting agen Kerangka Kerja Agen Microsoft di Azure Functions dengan titik akhir HTTP bawaan dan pemanggilan berbasis orkestrasi. Azure Functions menyediakan harga bayar per pemanggilan berbasis peristiwa dengan penskalaan otomatis dan manajemen infrastruktur minimal.

Saat Anda mengonfigurasi agen yang tahan lama di Azure Functions, ekstensi secara otomatis membuat titik akhir HTTP untuk agen Anda dan mengelola infrastruktur yang mendasar untuk menyimpan status percakapan, menangani permintaan bersamaan, dan mengoordinasikan alur kerja multi-agen. Integrasi hosting Azure Functions juga menyediakan kenyamanan khusus Functions seperti REST API yang dihasilkan untuk mengirim pesan, memeriksa status, dan mengelola sesi, ditambah pemicu seperti pemicu server MCP untuk agen hosting sebagai server MCP tanpa menulis lem pemicu.

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

Hosting bring-your-own-compute / self-hosted

Gunakan hosting bring-your-own-compute saat Anda menginginkan kemampuan Durable Extension tanpa menggunakan model pemrograman Azure Functions. Dalam model ini, proses Anda memulai Durable Task worker, mendaftarkan agen atau alur kerja yang tahan lama, dan menyambungkan ke backend Durable Task Scheduler. Kode klien dapat berjalan dalam proses yang sama atau dalam layanan terpisah.

Pekerja yang dihost sendiri menggunakan kemampuan Ekstensi Tahan Lama inti yang sama dengan hosting Azure Functions: titik pemeriksaan dan dimulai kembali, orkestrasi agen deterministik, alur kerja Kerangka Kerja Agen tahan lama, menunggu human-in-the-loop, streaming yang andal, pembersihan sesi diam, visibilitas dasbor, dan eksekusi terdistribusi di seluruh instans pekerja tanpa status. Host Anda bertanggung jawab untuk mengekspos API, manajemen siklus hidup, jaringan, autentikasi, dan model penyebarannya sendiri.

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

Alur kerja Durable Agent Framework

Durabilitas tidak terbatas pada orkestrasi tahan lama. Microsoft alur kerja Agent Framework yang dibangun dengan model alur kerja berbasis grafik juga dapat dibuat tahan lama. Eksekusi alur kerja titik pemeriksaan Ekstensi Tahan Lama sehingga langkah-langkah pelaksana dan agen yang selesai tidak diulang setelah proses dimulai ulang atau gagal.

Gunakan orkestrasi tahan lama saat Anda menginginkan koordinasi imperatif dengan percabangan berbasis kode, timer, aktivitas, dan peristiwa eksternal. Gunakan alur kerja Kerangka Kerja Agen tahan lama saat Anda menginginkan grafik deklaratif pelaksana dan agen dengan perutean yang diketik, fan-out/fan-in, tepi bersyarat, peristiwa alur kerja, status bersama, sub-alur kerja, atau port permintaan human-in-the-loop.

Contoh-contoh

Utas agen stateful dengan riwayat percakapan

Agen mempertahankan benang persisten yang bertahan selama beberapa interaksi. Setiap utas diidentifikasi oleh ID utas unik dan menyimpan riwayat percakapan lengkap dalam penyimpanan tahan lama yang dikelola oleh infrastruktur Durable Task, seperti Durable Task Scheduler.

Pola ini memungkinkan kelangsungan percakapan di mana keadaan agen dipertahankan melalui terjadinya crash dan restart proses, sehingga mampu mempertahankan riwayat percakapan secara penuh di seluruh utas pengguna. Penyimpanan tahan lama memastikan bahwa bahkan jika proses host dimulai ulang atau pekerjaan dilanjutkan pada instans pekerja yang berbeda, percakapan dengan mulus berlanjut dari tempat yang ditinggalkannya.

Gunakan pembersihan time-to-live (TTL) sesi untuk beban kerja yang membutuhkan kelangsungan yang tahan lama selama penggunaan aktif tetapi harus secara otomatis membersihkan percakapan diam. Pembersihan berbasis TTL mencegah sesi yang tidak digunakan dan riwayat percakapan terakumulasi tanpa batas waktu sambil mempertahankan status sesi aktif.

Contoh Azure Functions berikut menunjukkan beberapa permintaan HTTP ke utas yang sama, memperlihatkan bagaimana konteks percakapan berlanjut. Di aplikasi yang dihost sendiri, gunakan API klien Tugas Tahan Lama dari proses atau layanan Anda sendiri.

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

Status agen dipertahankan dalam penyimpanan tahan lama, memungkinkan eksekusi terdistribusi di beberapa instans. Instans apa pun dapat melanjutkan eksekusi agen setelah gangguan atau kegagalan, memastikan operasi berkelanjutan.

Dapat diandalkan streaming

Ekstensi Tahan Lama mendukung streaming yang andal untuk aplikasi yang membutuhkan pengiriman token real time dengan jaminan pengiriman yang tahan lama. Streaming dapat digunakan dengan ekstensi inti di kedua model hosting, tetapi host terdistribusi membutuhkan broker streaming yang andal, seperti Redis, sehingga aliran token dapat dikirimkan secara konsisten di seluruh proses restart, koneksi ulang, atau perubahan pekerja.

Gunakan streaming yang andal ketika pengalaman pengguna tergantung pada respons inkremental, tetapi beban kerja masih membutuhkan semantik eksekusi yang tahan lama. Untuk contoh yang dapat dijalankan, lihat sampel Python Durable Task, yang mencakup pola streaming yang andal.

Orkestrasi multi-agen deterministik

Ekstensi Tahan Lama mendukung membangun alur kerja deterministik yang mengoordinasikan beberapa agen menggunakan orkestrasi Tugas Tahan Lama. Dalam Azure Functions, ini menggunakan orkestrasi Durable Functions; dalam host bawa komputasi Anda sendiri, mereka berjalan melalui Durable Task worker dan klien yang Anda konfigurasi.

Orkestrasi adalah alur kerja berbasis kode yang mengoordinasikan beberapa operasi (seperti panggilan agen, panggilan API eksternal, atau timer) dengan cara yang dapat diandalkan. Deterministik berarti kode orkestrasi menjalankan cara yang sama ketika diputar ulang setelah kegagalan, membuat alur kerja dapat diandalkan dan dapat di-debug—saat Anda memutar ulang riwayat orkestrasi, Anda dapat melihat dengan tepat apa yang terjadi di setiap langkah.

Orkestrasi dijalankan dengan andal, bertahan terhadap kegagalan yang terjadi di antara panggilan agen, serta memberikan proses yang dapat diprediksi dan dapat diulang. Ini membuatnya ideal untuk skenario multi-agen yang kompleks di mana Anda memerlukan urutan eksekusi terjamin dan toleransi kesalahan.

Orkestrasi berurutan

Dalam pola multi-agen berurutan, agen khusus dijalankan dalam urutan tertentu, di mana setiap output agen dapat memengaruhi eksekusi agen berikutnya. Pola ini mendukung logika kondisional dan percabangan berdasarkan respons agen.

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

Orkestrasi mengoordinasikan pekerjaan di berbagai agen dan mampu bertahan dari kegagalan yang terjadi di antara panggilan agen. Konteks orkestrasi menyediakan metode untuk mengambil dan berinteraksi dengan agen terhosting dalam orkestrasi.

Orkestrasi paralel

Dalam pola multi-agen paralel, Anda menjalankan beberapa agen secara bersamaan dan kemudian menggabungkan hasilnya. Pola ini berguna untuk mengumpulkan beragam perspektif atau memproses subtugas independen secara bersamaan.

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', '')

Eksekusi paralel dilacak menggunakan daftar tugas. Titik pemeriksaan otomatis memastikan bahwa eksekusi agen yang selesai tidak diulang atau hilang jika kegagalan terjadi selama agregasi.

Orkestrasi human-in-the-loop

Orkestrasi agen deterministik dapat menjeda input, persetujuan, atau peninjauan manusia tanpa menggunakan sumber daya komputasi. Eksekusi tahan lama memungkinkan orkestrasi untuk menunggu bertahun-hari atau bahkan berminggu-minggu sambil menunggu respons manusia. Ketika dikombinasikan dengan hosting tanpa server, semua sumber daya komputasi dimatikan selama periode tunggu, menghilangkan biaya komputasi hingga ada masukan dari manusia.

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

Orkestrasi agen deterministik dapat menunggu peristiwa eksternal, secara stabil mempertahankan keadaan mereka sambil menunggu umpan balik manusia, menghadapi kegagalan, restart, dan periode menunggu yang diperpanjang. Ketika respons manusia tiba, orkestrasi secara otomatis berkelanjutan dengan konteks percakapan yang lengkap dan status eksekusi yang tetap utuh.

Memberikan input manusia

Untuk mengirim persetujuan atau input ke orkestrasi tunggu, ajukan peristiwa eksternal ke instans orkestrasi menggunakan SDK klien Tugas Tahan Lama atau titik akhir ekstensi Azure Functions Tahan Lama. Misalnya, peninjau mungkin menyetujui konten melalui formulir web yang memanggil:

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)

Efisiensi biaya

Alur kerja human-in-the-loop (manusia dalam lingkaran) dengan agen persisten sangat hemat biaya saat dihosting pada paket Flex Consumption Azure Functions. Untuk alur kerja yang menunggu 24 jam untuk persetujuan, Anda hanya membayar untuk beberapa detik waktu eksekusi (waktu untuk menghasilkan konten, mengirim pemberitahuan, dan memproses respons)—bukan 24 jam menunggu. Selama periode tunggu, tidak ada sumber daya komputasi yang digunakan.

Kemampuan Dapat Diamati dengan Durable Task Scheduler

Durable Task Scheduler (DTS) adalah backend tahan lama yang direkomendasikan untuk agen tahan lama Anda, menawarkan performa terbaik, infrastruktur yang dikelola sepenuhnya, dan pengamatan bawaan melalui dasbor UI. Azure Functions aplikasi dapat menggunakan backend penyimpanan lain (seperti Azure Storage), tetapi DTS dioptimalkan khusus untuk beban kerja yang tahan lama dan memberikan kemampuan performa dan pemantauan yang unggul. Pekerja yang dihost sendiri juga menggunakan DTS untuk penjadwalan, status, dan visibilitas dasbor yang tahan lama.

Wawasan sesi agen

• Riwayat percakapan: Menampilkan riwayat obrolan lengkap untuk setiap sesi agen, termasuk semua pesan, panggilan alat, dan konteks percakapan kapan saja
• Waktu tugas: Memantau berapa lama waktu yang diperlukan tugas tertentu dan interaksi agen untuk diselesaikan

Wawasan orkestrasi

• Visualisasi multi-agen: Lihat alur eksekusi saat memanggil beberapa agen khusus dengan representasi visual eksekusi paralel dan pencabangan bersyarat
• Riwayat eksekusi: Anda dapat mengakses log eksekusi yang terperinci
• Pemantauan real-time: Melacak orkestrasi aktif, item kerja dalam antrean, dan status agen di seluruh penyebaran Anda
• Metrik performa: Memantau waktu respons agen, penggunaan token, dan durasi orkestrasi

Kemampuan penelusuran kesalahan

• Melihat output agen terstruktur dan hasil panggilan alat
• Melacak pemanggilan fungsi alat dan hasilnya
• Memantau penanganan peristiwa eksternal untuk skenario Human-In-The-Loop (partisipasi manusia dalam proses)

Dasbor memungkinkan Anda memahami dengan tepat apa yang dilakukan agen Anda, mendiagnosis masalah dengan cepat, dan mengoptimalkan performa berdasarkan data eksekusi nyata.

Tutorial: Membuat dan menjalankan agen tahan lama dengan Azure Functions

Tutorial ini menunjukkan kepada Anda cara membuat dan menjalankan agen AI yang tahan lama menggunakan model hosting Azure Functions untuk Ekstensi Tahan Lama. Anda akan membuat aplikasi Azure Functions yang menghosting agen stateful dengan titik akhir HTTP bawaan, dan mempelajari cara memantaunya menggunakan dasbor Durable Task Scheduler. Untuk agen yang dihost sendiri, lihat sampelnya.

Prerequisites

Sebelum memulai, pastikan Anda memiliki prasyarat berikut:

Unduh proyek siap-guna

Gunakan Azure Developer CLI untuk menginisialisasi proyek baru dari templat panduan memulai cepat agen durable.

Penyediaan sumber daya Azure

Gunakan Azure Developer CLI untuk membuat sumber daya Azure yang diperlukan untuk agen tahan lama Anda.

1. Provisikan infrastruktur:

   azd provision
   

   Perintah ini membuat:

   • Layanan Azure OpenAI dengan implementasi gpt-4o-mini
   • Aplikasi Azure Functions dengan skema hosting Flex Consumption
   • Akun Azure Storage untuk menjalankan Azure Functions dan penyimpanan yang berkelanjutan
   • Instans Durable Task Scheduler (Skema konsumsi) untuk mengelola status agen
   • Konfigurasi jaringan dan identitas yang diperlukan

2. Saat diminta, pilih langganan Azure Anda dan pilih lokasi untuk sumber daya.

Proses provisi membutuhkan waktu beberapa menit. Setelah selesai, azd menyimpan informasi sumber daya yang dibuat di lingkungan Anda.

Meninjau kode agen

Sekarang mari kita periksa kode yang mendefinisikan agen tahan lama Anda.

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

Agen sekarang siap untuk dihosting di Azure Functions. Ekstensi tugas yang tahan lama secara otomatis membuat titik akhir HTTP untuk berinteraksi dengan agen Anda dan mengelola status percakapan sepanjang beberapa permintaan.

Mengonfigurasi pengaturan lokal

Buat local.settings.json file untuk pengembangan lokal berdasarkan file sampel yang disertakan dalam proyek.

1. Salin file pengaturan sampel:

   • Bash
   • PowerShell

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

1. Dapatkan titik akhir Azure OpenAI Anda dari sumber daya yang disediakan:

   azd env get-value AZURE_OPENAI_ENDPOINT
   

2. Buka local.settings.json dan ganti <your-resource-name> dalam nilai AZURE_OPENAI_ENDPOINT dengan titik akhir dari perintah sebelumnya.

Anda local.settings.json akan terlihat seperti ini:

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

Memulai dependensi pengembangan lokal

Untuk menjalankan agen tahan lama secara lokal, Anda perlu memulai dua layanan:

• Azurite: Meniru layanan Azure Storage (digunakan oleh Azure Functions untuk mengelola pemicu dan status internal).
• Durable Task Scheduler (DTS) Emulator: Mengelola status stabil (riwayat percakapan, status orkestrasi) dan penjadwalan untuk agen-agen Anda

Mulai Azurite

Azurite mengemulasi layanan Azure Storage secara lokal. Azure Functions menggunakannya untuk mengelola status internal. Anda harus menjalankan ini di jendela terminal baru dan membuatnya tetap berjalan saat Anda mengembangkan dan menguji agen tahan lama Anda.

1. Buka jendela terminal baru dan tarik gambar Azurite Docker:

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

2. Mulai Azurite di jendela terminal:

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

   Azurite akan memulai dan mendengarkan port default untuk layanan Blob (10000), Antrean (10001), dan Tabel (10002).

Biarkan jendela terminal ini tetap terbuka saat Anda mengembangkan dan menguji agen tahan lama Anda.

Mulai emulator Durable Task Scheduler

Emulator DTS menyediakan backend tahan lama untuk mengelola status agen dan orkestrasi. Ini menyimpan riwayat percakapan dan memastikan status agen Anda tetap ada di seluruh restart. Ini juga memicu orkestrasi dan agen yang tahan lama. Anda harus menjalankan ini di jendela terminal baru yang terpisah dan membuatnya tetap berjalan saat Anda mengembangkan dan menguji agen tahan lama Anda.

1. Buka jendela terminal baru lainnya dan tarik gambar Docker emulator DTS:

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

2. Jalankan emulator DTS:

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

   Perintah ini memulai emulator dan mengekspos:

   • Port 8080: Titik akhir gRPC untuk Durable Task Scheduler (digunakan oleh aplikasi Functions Anda)
   • Port 8082: Dasbor administratif

3. Dasbor akan tersedia di http://localhost:8082.

Biarkan jendela terminal ini tetap terbuka saat Anda mengembangkan dan menguji agen tahan lama Anda.

Menjalankan aplikasi fungsi

Sekarang Anda siap untuk menjalankan aplikasi Azure Functions anda dengan agen yang tahan lama.

1. Di jendela terminal baru (menjaga emulator Azurite dan DTS berjalan di jendela terpisah), navigasikan ke direktori proyek Anda.

2. Jalankan runtime Azure Functions:

   func start
   

3. Anda akan melihat output yang menunjukkan bahwa aplikasi fungsi Anda berjalan, termasuk titik akhir HTTP untuk agen Anda:

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

Titik akhir ini mengelola status percakapan secara otomatis - Anda tidak perlu membuat atau mengelola objek utas sendiri.

Menguji agen di lingkungan lokal

Sekarang Anda dapat berinteraksi dengan agen tahan lama Anda menggunakan permintaan HTTP. Agen mempertahankan status percakapan di beberapa permintaan, memungkinkan percakapan berkelanjutan.

Memulai percakapan baru

Buat utas baru dan kirim pesan pertama Anda:

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

Contoh respons (perhatikan x-ms-thread-id header berisi ID utas):

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.

Simpan ID utas dari x-ms-thread-id header (misalnya, @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d) untuk permintaan berikutnya.

Melanjutkan percakapan

Kirim pesan tindak lanjut ke utas yang sama dengan menyertakan ID utas sebagai parameter kueri:

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

Ganti @dafx-mydurableagent@263fa373-fa01-4705-abf2-5a114c2bb87d dengan ID thread yang sebenarnya dari header respons sebelumnya x-ms-thread-id.

Contoh respons:

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.

Perhatikan bahwa agen mengingat konteks dari pesan sebelumnya (tiga bahasa pemrograman) tanpa Anda harus menentukannya lagi. Karena status percakapan disimpan dengan durably oleh Durable Task Scheduler, riwayat ini tetap ada bahkan jika Anda memulai ulang aplikasi fungsi atau percakapan dilanjutkan oleh instans yang berbeda.

Memantau dengan dasbor Durable Task Scheduler

Durable Task Scheduler menyediakan dasbor bawaan untuk memantau dan memecahkan masalah agen durabel Anda. Dasbor menawarkan visibilitas mendalam ke dalam operasi agen, riwayat percakapan, dan alur eksekusi.

Akses dasbor

1. Buka dasbor untuk emulator DTS lokal Anda di http://localhost:8082 browser web Anda.

2. Pilih hub tugas default dari daftar untuk menampilkan detailnya.

3. Pilih ikon roda gigi di sudut kanan atas untuk membuka pengaturan, dan pastikan bahwa opsi Aktifkan halaman Agen di bawah Fitur Pratinjau dipilih.

Menjelajahi percakapan agen

1. Di dasbor, navigasikan ke tab Agen .

2. Pilih utas agen tahan lama Anda (misalnya, mydurableagent - 263fa373-fa01-4705-abf2-5a114c2bb87d) dari daftar.

   Anda akan melihat tampilan terperinci utas agen, termasuk riwayat percakapan lengkap dengan semua pesan dan respons.

   

Dasbor menyediakan tampilan garis waktu untuk membantu Anda memahami alur percakapan. Informasi utama meliputi:

• Tanda waktu dan durasi untuk setiap interaksi
• Konten perintah dan respons
• Jumlah token yang digunakan

Sebarkan ke Azure

Sekarang setelah Anda menguji agen tahan lama Anda secara lokal, sebarkan ke Azure.

1. Sebarkan aplikasi:

   azd deploy
   

   Perintah ini mengemas aplikasi Anda dan meng-deploy-nya ke aplikasi Azure Functions yang dibuat selama proses provisi.

2. Tunggu hingga penerapan selesai. Output akan mengonfirmasi kapan agen Anda berjalan di Azure.

Menguji agen yang terpasang

Setelah penyebaran, uji agen Anda yang berjalan di Azure.

Mendapatkan kunci fungsi

Azure Functions memerlukan kunci API untuk fungsi yang dipicu HTTP dalam produksi:

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

Memulai percakapan baru di Azure

Buat utas baru dan kirim pesan pertama Anda ke agen yang telah di-deploy.

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

Perhatikan ID utas yang dikembalikan di x-ms-thread-id tajuk respons.

Melanjutkan percakapan di Azure

Kirim pesan tindak lanjut di utas yang sama. Ganti <thread-id> dengan ID utas dari respons sebelumnya:

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

Agen mempertahankan konteks percakapan di Azure seperti yang dilakukan secara lokal, menunjukkan durabilitas status agen.

Memantau agen yang disebarkan

Anda dapat memantau agen yang disebarkan melalui dasbor Durable Task Scheduler di Azure.

1. Dapatkan nama instans Durable Task Scheduler Anda:

   azd env get-value DTS_NAME
   

2. Buka portal Microsoft Azure dan cari nama Durable Task Scheduler dari langkah sebelumnya.

3. Di bilah gambaran umum sumber daya Durable Task Scheduler, pilih hub tugas default dari daftar.

4. Pilih Buka Dasbor di bagian atas halaman hub tugas untuk membuka dasbor pemantauan.

5. Lihat percakapan agen Anda seperti yang Anda lakukan dengan emulator lokal.

Dasbor yang dihosting Azure menyediakan kemampuan penelusuran kesalahan dan pemantauan yang sama dengan emulator lokal, memungkinkan Anda memeriksa riwayat percakapan, melacak panggilan alat, dan menganalisis performa di lingkungan produksi Anda.

Tutorial: Mengatur agen tahan lama dengan Azure Functions

Tutorial ini menunjukkan kepada Anda cara mengatur beberapa agen AI tahan lama menggunakan model hosting Azure Functions dan pola fan-out/fan-in. Anda akan memperluas agen tahan lama dari tutorial sebelumnya untuk membuat sistem multi-agen yang memproses pertanyaan pengguna, lalu menerjemahkan respons ke dalam beberapa bahasa secara bersamaan. Untuk contoh orkestrasi yang dihost sendiri, lihat sampelnya.

Memahami pola orkestrasi

Orkestrasi yang akan Anda buat mengikuti alur ini:

1. Input pengguna - Pertanyaan atau pesan dari pengguna
2. Agen utama - MyDurableAgent dari tutorial pertama yang memproses pertanyaan
3. Fan-out - Pesan respon agen utama dikirim secara bersamaan ke kedua agen terjemahan
4. Agen terjemahan - Dua agen khusus menerjemahkan respons (Prancis dan Spanyol)
5. Fan-in - Hasil dikumpulkan ke dalam satu respons JSON dengan respons dan terjemahan asli

Pola ini memungkinkan pemrosesan bersamaan, mengurangi total waktu respons dibandingkan dengan terjemahan berurutan.

Mendaftarkan agen pada saat memulai

Untuk menggunakan agen dengan benar dalam orkestrasi tahan lama, daftarkan di awal aplikasi. Mereka dapat digunakan di seluruh pelaksanaan orkestrasi.

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

Membuat fungsi orkestrasi

Fungsi orkestrasi mengoordinasikan alur kerja di beberapa agen. Ia mengambil kembali agen terdaftar dari konteks yang berkelanjutan dan mengorkestrasi eksekusi mereka, pertama-tama memanggil agen utama, kemudian menyebar ke agen terjemahan secara bersamaan.

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

Menguji orkestrasi

Pastikan dependensi pengembangan lokal Anda dari tutorial pertama masih berjalan:

• Azurite dalam satu jendela terminal
• Emulator Durable Task Scheduler di jendela terminal lain

Dengan menjalankan dependensi pengembangan lokal Anda

1. Mulai aplikasi Azure Functions Anda di jendela terminal baru:

   func start
   

2. Ekstensi Durable Functions secara otomatis membuat titik akhir HTTP bawaan untuk mengelola orkestrasi. Mulai orkestrasi menggunakan API bawaan:

   • 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. Respons mencakup URL untuk mengelola instans orkestrasi:

   {
     "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. Kueri status orkestrasi menggunakan statusQueryGetUri (ganti abc123def456 dengan ID instans Anda yang sebenarnya):

   • Bash
   • PowerShell

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

1. Memeriksa titik akhir status sampai runtimeStatus adalah Completed. Setelah selesai, Anda akan melihat output orkestrasi dengan respons agen utama dan terjemahannya:

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

Pantau orkestrasi di dasbor

Dasbor Durable Task Scheduler memberikan visibilitas ke dalam orkestrasi Anda:

1. Buka http://localhost:8082 di browser Anda.

2. Pilih hub tugas "default".

3. Pilih tab "Orkestrasi".

4. Temukan instans orkestrasi Anda dalam daftar.

5. Pilih instans untuk melihat:

   • Garis waktu orkestrasi
   • Eksekusi agen utama diikuti oleh agen penerjemahan bersamaan
   • Setiap pelaksanaan agen (MyDurableAgent, serta penerjemah Prancis dan Spanyol)
   • Pola fan-out dan fan-in divisualisasikan
   • Waktu dan durasi untuk setiap langkah

Menyebarkan orkestrasi ke Azure

Sebarkan aplikasi yang diperbarui menggunakan Azure Developer CLI:

azd deploy

Ini menyebarkan kode yang diperbarui dengan fungsi orkestrasi baru dan agen tambahan ke aplikasi Azure Functions yang dibuat di tutorial pertama.

Menguji orkestrasi yang telah diterapkan

Setelah penyebaran, lakukan pengujian terhadap orkestrasi Anda yang berjalan di Azure.

1. Dapatkan kunci sistem untuk ekstensi tahan lama:

   • 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. Mulai orkestrasi menggunakan API bawaan:

   • 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. statusQueryGetUri Gunakan dari respons ke polling untuk penyelesaian dan lihat hasilnya dengan terjemahan.

Langkah berikutnya

Sumber daya tambahan:

• ekstensi Tugas Durable untuk Microsoft Agent Framework
• Gambaran Umum Penjadwal Tugas Tahan Lama
• Dasbor Penjadwal Tugas Berkelanjutan
• Paket Konsumsi Flex Azure Functions
• Pola dan konsep Durable Functions