Orkestrasi Alur Kerja Kerangka Kerja Agen Microsoft - Obrolan Grup

Orkestrasi obrolan grup memodelkan percakapan kolaboratif di antara beberapa agen, yang dikoordinasikan oleh orkestrator yang menentukan pemilihan pembicara dan alur percakapan. Pola ini sangat ideal untuk skenario yang memerlukan penyempurnaan berulang, pemecahan masalah kolaboratif, atau analisis multi-perspektif.

Secara internal, orkestrasi obrolan grup menggabungkan agen dalam topologi bintang, dengan orkestrator di tengah. Orkestrator dapat menerapkan berbagai strategi untuk memilih agen mana yang berbicara berikutnya, seperti round-robin, pemilihan berbasis prompt, atau logika kustom berdasarkan konteks percakapan, menjadikannya pola yang fleksibel dan kuat untuk kolaborasi multi-agen.

Perbedaan Antara Obrolan Grup dan Pola Lainnya

Orkestrasi obrolan grup memiliki karakteristik yang berbeda dibandingkan dengan pola multi-agen lainnya:

• Koordinasi Terpusat: Tidak seperti pola handoff di mana agen langsung mentransfer kontrol, obrolan grup menggunakan orkestrator untuk mengoordinasikan siapa yang berbicara berikutnya
• Perbaikan Berulang: Agen dapat meninjau dan membangun respons satu sama lain dalam beberapa putaran
• Pemilihan Pembicara Fleksibel: Orkestrator dapat menggunakan berbagai strategi (round-robin, berbasis perintah, logika kustom) untuk memilih speaker
• Konteks Bersama: Semua agen melihat riwayat percakapan lengkap, memungkinkan penyempurnaan kolaboratif

Apa yang akan Anda Pelajari

• Cara membuat agen khusus untuk kolaborasi grup
• Cara mengonfigurasi strategi pemilihan pembicara
• Cara membangun alur kerja dengan pemurnian agen iteratif
• Cara mengkustomisasi alur percakapan dengan orkestrator kustom

Menyiapkan Klien Azure OpenAI

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

// Set up the Azure OpenAI client
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ??
    throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
var client = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();

Peringatan

DefaultAzureCredential nyaman untuk pengembangan tetapi membutuhkan pertimbangan yang cermat dalam produksi. Dalam produksi, pertimbangkan untuk menggunakan kredensial tertentu (misalnya, ManagedIdentityCredential) untuk menghindari masalah latensi, pemeriksaan kredensial yang tidak diinginkan, dan potensi risiko keamanan dari mekanisme fallback.

Tentukan Agen Anda

Buat agen khusus untuk peran yang berbeda dalam percakapan grup:

// Create a copywriter agent
ChatClientAgent writer = new(client,
    "You are a creative copywriter. Generate catchy slogans and marketing copy. Be concise and impactful.",
    "CopyWriter",
    "A creative copywriter agent");

// Create a reviewer agent
ChatClientAgent reviewer = new(client,
    "You are a marketing reviewer. Evaluate slogans for clarity, impact, and brand alignment. " +
    "Provide constructive feedback or approval.",
    "Reviewer",
    "A marketing review agent");

Mengonfigurasi Obrolan Grup dengan Orkestrator Round-Robin

Buat alur kerja obrolan grup menggunakan AgentWorkflowBuilder:

// Build group chat with round-robin speaker selection
// The manager factory receives the list of agents and returns a configured manager
var workflow = AgentWorkflowBuilder
    .CreateGroupChatBuilderWith(agents =>
        new RoundRobinGroupChatManager(agents)
        {
            MaximumIterationCount = 5  // Maximum number of turns
        })
    .AddParticipants(writer, reviewer)
    .Build();

Jalankan Alur Kerja Obrolan Grup

Jalankan alur kerja dan amati percakapan berulang:

// Start the group chat
var messages = new List<ChatMessage> {
    new(ChatRole.User, "Create a slogan for an eco-friendly electric vehicle.")
};

StreamingRun run = await InProcessExecution.StreamAsync(workflow, messages);
await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
{
    if (evt is AgentResponseUpdateEvent update)
    {
        // Process streaming agent responses
        AgentResponse response = update.AsResponse();
        foreach (ChatMessage message in response.Messages)
        {
            Console.WriteLine($"[{update.ExecutorId}]: {message.Text}");
        }
    }
    else if (evt is WorkflowOutputEvent output)
    {
        // Workflow completed
        var conversationHistory = output.As<List<ChatMessage>>();
        Console.WriteLine("\n=== Final Conversation ===");
        foreach (var message in conversationHistory)
        {
            Console.WriteLine($"{message.AuthorName}: {message.Text}");
        }
        break;
    }
}

Interaksi Contoh

[CopyWriter]: "Green Dreams, Zero Emissions" - Drive the future with style and sustainability.

[Reviewer]: The slogan is good, but "Green Dreams" might be a bit abstract. Consider something
more direct like "Pure Power, Zero Impact" to emphasize both performance and environmental benefit.

[CopyWriter]: "Pure Power, Zero Impact" - Experience electric excellence without compromise.

[Reviewer]: Excellent! This slogan is clear, impactful, and directly communicates the key benefits.
The tagline reinforces the message perfectly. Approved for use.

[CopyWriter]: Thank you! The final slogan is: "Pure Power, Zero Impact" - Experience electric
excellence without compromise.

Menyiapkan Aplikasi Obrolan

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Initialize the Azure OpenAI chat client
chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

Tentukan Agen Anda

Buat agen khusus dengan peran yang berbeda:

from agent_framework import Agent

# Create a researcher agent
researcher = Agent(
    name="Researcher",
    description="Collects relevant background information.",
    instructions="Gather concise facts that help answer the question. Be brief and factual.",
    chat_client=chat_client,
)

# Create a writer agent
writer = Agent(
    name="Writer",
    description="Synthesizes polished answers using gathered information.",
    instructions="Compose clear, structured answers using any notes provided. Be comprehensive.",
    chat_client=chat_client,
)

Menyiapkan Obrolan Grup dengan Selector Sederhana

Buat obrolan grup dengan logika pemilihan pembicara kustom:

from agent_framework.orchestrations import GroupChatBuilder, GroupChatState

def round_robin_selector(state: GroupChatState) -> str:
    """A round-robin selector function that picks the next speaker based on the current round index."""

    participant_names = list(state.participants.keys())
    return participant_names[state.current_round % len(participant_names)]


# Build the group chat workflow
workflow = GroupChatBuilder(
    participants=[researcher, writer],
    termination_condition=lambda conversation: len(conversation) >= 4,
    selection_func=round_robin_selector,
).build()

Mengonfigurasi Obrolan Grup dengan Orkestrator Berbasis Agen

Atau, gunakan orkestrator berbasis agen untuk pemilihan pembicara cerdas. Orkestrator adalah Agent penuh dengan akses ke alat, konteks, dan kemampuan observasi.

# Create orchestrator agent for speaker selection
orchestrator_agent = Agent(
    name="Orchestrator",
    description="Coordinates multi-agent collaboration by selecting speakers",
    instructions="""
You coordinate a team conversation to solve the user's task.

Guidelines:
- Start with Researcher to gather information
- Then have Writer synthesize the final answer
- Only finish after both have contributed meaningfully
""",
    chat_client=chat_client,
)

# Build group chat with agent-based orchestrator
workflow = GroupChatBuilder(
    participants=[researcher, writer],
    # Set a hard termination condition: stop after 4 assistant messages
    # The agent orchestrator will intelligently decide when to end before this limit but just in case
    termination_condition=lambda messages: sum(1 for msg in messages if msg.role == "assistant") >= 4,
    orchestrator_agent=orchestrator_agent,
).build()

Jalankan Alur Kerja Obrolan Grup

Jalankan alur kerja dan memproses acara.

from typing import cast
from agent_framework import AgentResponseUpdate, Role

task = "What are the key benefits of async/await in Python?"

print(f"Task: {task}\n")
print("=" * 80)

final_conversation: list[Message] = []
last_executor_id: str | None = None

# Run the workflow
async for event in workflow.run_stream(task):
    if event.type == "output" and isinstance(event.data, AgentResponseUpdate):
        # Print streaming agent updates
        eid = event.executor_id
        if eid != last_executor_id:
            if last_executor_id is not None:
                print()
            print(f"[{eid}]:", end=" ", flush=True)
            last_executor_id = eid
        print(event.data, end="", flush=True)
    elif event.type == "output":
        # Workflow completed - data is a list of Message
        final_conversation = cast(list[Message], event.data)

if final_conversation:
    print("\n\n" + "=" * 80)
    print("Final Conversation:")
    for msg in final_conversation:
        author = getattr(msg, "author_name", "Unknown")
        text = getattr(msg, "text", str(msg))
        print(f"\n[{author}]\n{text}")
        print("-" * 80)

print("\nWorkflow completed.")

Interaksi Contoh

Task: What are the key benefits of async/await in Python?

================================================================================

[Researcher]: Async/await in Python provides non-blocking I/O operations, enabling
concurrent execution without threading overhead. Key benefits include improved
performance for I/O-bound tasks, better resource utilization, and simplified
concurrent code structure using native coroutines.

[Writer]: The key benefits of async/await in Python are:

1. **Non-blocking Operations**: Allows I/O operations to run concurrently without
   blocking the main thread, significantly improving performance for network
   requests, file I/O, and database queries.

2. **Resource Efficiency**: Avoids the overhead of thread creation and context
   switching, making it more memory-efficient than traditional threading.

3. **Simplified Concurrency**: Provides a clean, synchronous-looking syntax for
   asynchronous code, making concurrent programs easier to write and maintain.

4. **Scalability**: Enables handling thousands of concurrent connections with
   minimal resource consumption, ideal for high-performance web servers and APIs.

--------------------------------------------------------------------------------

Workflow completed.

Konsep utama

• Manajer Terpusat: Obrolan grup menggunakan manajer untuk mengoordinasikan pemilihan dan alur pembicara
• AgentWorkflowBuilder.CreateGroupChatBuilderWith(): Membuat alur kerja dengan fungsi factory manager
• RoundRobinGroupChatManager: Manajer bawaan yang mengatur pergantian peserta secara bergilir
• MaximumIterationCount: Mengontrol jumlah maksimum putaran agen sebelum dihentikan
• Manajer Kustom: Memperluas RoundRobinGroupChatManager atau menerapkan logika kustom
• Perbaikan Berulang: Agen meninjau dan meningkatkan kontribusi satu sama lain
• Konteks Bersama: Semua peserta melihat riwayat percakapan lengkap

• Strategi Orkestrator Fleksibel: Pilih antara pemilih sederhana, orkestrator berbasis agen, atau logika kustom melalui parameter konstruktor (selection_func, orchestrator_agent, atau orchestrator).
• GroupChatBuilder: Membuat alur kerja dengan pilihan pembicara yang dapat dikonfigurasi
• GroupChatState: Menyediakan status percakapan untuk keputusan pemilihan
• Kolaborasi Berulang: Agen membangun kontribusi satu sama lain
• Event Streaming: Memproses WorkflowOutputEvent dengan AgentResponseUpdate data secara real-time
• list[Message] Output: Semua orkestrasi mengembalikan daftar pesan obrolan

Tingkat Lanjut: Pemilihan Pembicara Kustom

Anda dapat menerapkan logika manajer kustom dengan membuat manajer obrolan grup kustom:

public class ApprovalBasedManager : RoundRobinGroupChatManager
{
    private readonly string _approverName;

    public ApprovalBasedManager(IReadOnlyList<AIAgent> agents, string approverName)
        : base(agents)
    {
        _approverName = approverName;
    }

    // Override to add custom termination logic
    protected override ValueTask<bool> ShouldTerminateAsync(
        IReadOnlyList<ChatMessage> history,
        CancellationToken cancellationToken = default)
    {
        var last = history.LastOrDefault();
        bool shouldTerminate = last?.AuthorName == _approverName &&
            last.Text?.Contains("approve", StringComparison.OrdinalIgnoreCase) == true;

        return ValueTask.FromResult(shouldTerminate);
    }
}

// Use custom manager in workflow
var workflow = AgentWorkflowBuilder
    .CreateGroupChatBuilderWith(agents =>
        new ApprovalBasedManager(agents, "Reviewer")
        {
            MaximumIterationCount = 10
        })
    .AddParticipants(writer, reviewer)
    .Build();

Anda dapat menerapkan logika pemilihan canggih berdasarkan status percakapan:

def smart_selector(state: GroupChatState) -> str:
    """Select speakers based on conversation content and context."""
    conversation = state.conversation

    last_message = conversation[-1] if conversation else None

    # If no messages yet, start with Researcher
    if not last_message:
        return "Researcher"

    # Check last message content
    last_text = last_message.text.lower()

    # If researcher finished gathering info, switch to writer
    if "I have finished" in last_text and last_message.author_name == "Researcher":
        return "Writer"

    # Else continue with researcher until it indicates completion
    return "Researcher"

workflow = GroupChatBuilder(
    participants=[researcher, writer],
    selection_func=smart_selector,
).build()

Penting

Saat menggunakan implementasi BaseGroupChatOrchestrator kustom untuk skenario tingkat lanjut, semua properti harus diatur, termasuk participant_registry, , max_roundsdan termination_condition. max_rounds dan termination_condition yang diatur dalam penyusun akan diabaikan.

Sinkronisasi Konteks

Seperti disebutkan di awal panduan ini, semua agen dalam obrolan grup melihat riwayat percakapan lengkap.

Agen dalam Kerangka Kerja Agen bergantung pada sesi agen (AgentSession) untuk mengelola konteks. Dalam pengaturan obrolan grup, agen tidak berbagi instans sesi yang sama, tetapi pengatur memastikan bahwa setiap sesi agen disinkronkan dengan riwayat percakapan lengkap sebelum setiap giliran. Untuk mencapai hal ini, setelah giliran setiap agen, orkestrator menyiarkan respons ke semua agen lain, memastikan semua peserta memiliki konteks terbaru untuk giliran mereka berikutnya.

Petunjuk / Saran

Agen tidak berbagi instans sesi yang sama karena jenis agen yang berbeda mungkin memiliki implementasi abstraksi yang AgentSession berbeda. Berbagi instans sesi yang sama dapat menyebabkan inkonsistensi dalam cara setiap agen memproses dan mempertahankan konteks.

Setelah menyiarkan respons, orkestrator kemudian memutuskan pembicara berikutnya dan mengirim permintaan ke agen yang dipilih, yang sekarang memiliki riwayat percakapan lengkap untuk menghasilkan responsnya.

Kapan Menggunakan Obrolan Grup

Orkestrasi obrolan grup sangat ideal untuk:

• Penyempurnaan Berulang: Beberapa putaran tinjauan dan peningkatan
• Pemecahan Masalah Kolaboratif: Agen dengan keahlian pelengkap bekerja sama
• Pembuatan Konten: Alur kerja Writer-reviewer untuk pembuatan dokumen
• Analisis Multi-Perspektif: Mendapatkan beragam titik pandang pada input yang sama
• Jaminan Kualitas: Tinjauan otomatis dan proses persetujuan

Pertimbangkan alternatif saat:

• Anda memerlukan pemrosesan berurutan yang ketat (gunakan orkestrasi Berurutan)
• Agen-agen harus bekerja dengan independen penuh (menggunakan orkestrasi bersamaan)
• Pemindahan langsung dari agen-ke-agen diperlukan (gunakan orkestrasi pemindahan)
• Perencanaan dinamis yang kompleks diperlukan (gunakan orkestrasi Magentik)

Langkah selanjutnya

Orkestrasi Magnetik