Csoportos chat szervezése

Fontos

Az Ügynök-keretrendszer ügynök-vezénylési funkciói a kísérleti fázisban vannak. Aktív fejlesztés alatt állnak, és jelentősen változhatnak, mielőtt továbblépnének az előzetes verzióra vagy a kiadásra jelölt fázisra.

A csoportos csevegés vezénylése együttműködési beszélgetést modellez az ügynökök között, opcionálisan egy emberi résztvevőt is beleértve. A csoportos csevegés-kezelő koordinálja a folyamatot, meghatározva, hogy melyik ügynök válaszoljon legközelebb, és mikor kérjen emberi bemenetet. Ez a minta hatékony az értekezletek, viták vagy együttműködésen alapuló problémamegoldó munkamenetek szimulálásához.

Ha többet szeretne megtudni a mintáról, például arról, hogy mikor érdemes használni a mintát, vagy mikor szeretné elkerülni a mintát a számítási feladatban, olvassa el a csoportos csevegés vezénylését.

Gyakori használati esetek

A különböző részlegeket képviselő ügynökök megvitatnak egy üzleti javaslatot, egy menedzserügynök moderálásával és szükség esetén egy ember bevonásával:

diagram

Tudnivalók

  • Különböző szerepkörökkel rendelkező ügynökök definiálása csoportos csevegéshez
  • Csoportos csevegés-kezelő használata a beszélgetés folyamatának szabályozásához
  • Emberi résztvevő bevonása a beszélgetésbe
  • A beszélgetés megfigyelése és a végeredmény összegyűjtése

Az ügynökök definiálása

A csoportos csevegés minden ügynöke rendelkezik egy adott szerepkörrel. Ebben a példában egy szövegírót és egy véleményezőt határozunk meg.

Jótanács

Ez ChatCompletionAgent itt használatos, de bármilyen ügynöktípust használhat.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Agents;
using Microsoft.SemanticKernel.Agents.Orchestration;
using Microsoft.SemanticKernel.Agents.Orchestration.GroupChat;
using Microsoft.SemanticKernel.Agents.Runtime.InProcess;

// Create a kernel with an AI service
Kernel kernel = ...;

ChatCompletionAgent writer = new ChatCompletionAgent {
    Name = "CopyWriter",
    Description = "A copy writer",
    Instructions = "You are a copywriter with ten years of experience and are known for brevity and a dry humor. The goal is to refine and decide on the single best copy as an expert in the field. Only provide a single proposal per response. You're laser focused on the goal at hand. Don't waste time with chit chat. Consider suggestions when refining an idea.",
    Kernel = kernel,
};

ChatCompletionAgent editor = new ChatCompletionAgent {
    Name = "Reviewer",
    Description = "An editor.",
    Instructions = "You are an art director who has opinions about copywriting born of a love for David Ogilvy. The goal is to determine if the given copy is acceptable to print. If so, state that it is approved. If not, provide insight on how to refine suggested copy without example.",
    Kernel = kernel,
};

Nem kötelező: Ügynökválaszok megfigyelése

Létrehozhat egy visszahívást az ügynök válaszainak rögzítéséhez, amint a sorozat a ResponseCallback tulajdonságon keresztül halad előre.

ChatHistory history = [];

ValueTask responseCallback(ChatMessageContent response)
{
    history.Add(response);
    return ValueTask.CompletedTask;
}

A csoportos csevegés vezénylése beállítása

Hozzon létre egy GroupChatOrchestration objektumot, adja át az ügynököknek, egy csoportos csevegés-kezelőt (itt, a ), és a válaszvisszahívást RoundRobinGroupChatManager. A vezető vezérli az áramlást – itt körkörös váltakozó módon zajlik a váltás meghatározott számú kör esetén.

GroupChatOrchestration orchestration = new GroupChatOrchestration(
    new RoundRobinGroupChatManager { MaximumInvocationCount = 5 },
    writer,
    editor)
{
    ResponseCallback = responseCallback,
};

A futtatókörnyezet indítása

Az ügynökök végrehajtásának kezeléséhez futtatókörnyezetre van szükség. Itt a vezénylés megkezdése előtt használjuk InProcessRuntime és indítjuk el.

InProcessRuntime runtime = new InProcessRuntime();
await runtime.StartAsync();

Orchestráció meghívása

Hívja meg az orchestrationt az kezdeti feladattal (pl. "Szlogen megalkotása új elektromos SUV-hoz..."). Az ügynökök felváltva válaszolnak, és finomítják az eredményt.

var result = await orchestration.InvokeAsync(
    "Create a slogan for a new electric SUV that is affordable and fun to drive.",
    runtime);

Eredmények gyűjtése

Várja meg, amíg az orchestration befejeződik, és szerezze meg a végső kimenetet.

string output = await result.GetValueAsync(TimeSpan.FromSeconds(60));
Console.WriteLine($"\n# RESULT: {text}");
Console.WriteLine("\n\nORCHESTRATION HISTORY");
foreach (ChatMessageContent message in history)
{
    this.WriteAgentChatMessage(message);
}

Opcionális: A futtatókörnyezet leállítása

A feldolgozás befejezése után állítsa le a futtatókörnyezetet az erőforrások törléséhez.

await runtime.RunUntilIdleAsync();

Mintakimenet

# RESULT: “Affordable Adventure: Drive Electric, Drive Fun.”


ORCHESTRATION HISTORY

# Assistant - CopyWriter: “Charge Ahead: Affordable Thrills, Zero Emissions.”

# Assistant - Reviewer: The slogan is catchy but it could be refined to better ...

# Assistant - CopyWriter: “Electrify Your Drive: Fun Meets Affordability.”

# Assistant - Reviewer: The slogan captures the essence of electric driving and ...

# Assistant - CopyWriter: “Affordable Adventure: Drive Electric, Drive Fun.”

Jótanács

A teljes mintakód itt érhető el

Az ügynökök definiálása

A csoportos csevegés minden ügynöke rendelkezik egy adott szerepkörrel. Ebben a példában:

  • Író: Visszajelzés alapján hoz létre és szerkeszt tartalmakat.
  • Véleményező: Áttekinti a tartalmat, és visszajelzést ad a fejlesztéshez.

Jótanács

Ez ChatCompletionAgent az Azure OpenAI-val használható, azonban bármilyen ügynöktípust vagy modellszolgáltatást használhat.

from semantic_kernel.agents import Agent, ChatCompletionAgent
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

def get_agents() -> list[Agent]:
    writer = ChatCompletionAgent(
        name="Writer",
        description="A content writer.",
        instructions=(
            "You are an excellent content writer. You create new content and edit contents based on the feedback."
        ),
        service=AzureChatCompletion(),
    )
    reviewer = ChatCompletionAgent(
        name="Reviewer",
        description="A content reviewer.",
        instructions=(
            "You are an excellent content reviewer. You review the content and provide feedback to the writer."
        ),
        service=AzureChatCompletion(),
    )
    return [writer, reviewer]

Ügynökválaszok megfigyelése

Meghatározhatja a visszahívási funkciót, amely kiírja az egyes ügynökök üzenetét, miközben a beszélgetés előrehalad.

from semantic_kernel.contents import ChatMessageContent

def agent_response_callback(message: ChatMessageContent) -> None:
    print(f"**{message.name}**\n{message.content}")

A csoportos csevegés vezénylése beállítása

Hozzon létre egy GroupChatOrchestration objektumot, adja át az ügynököket, egy csoportos csevegéskezelőt (ebben az esetben egy RoundRobinGroupChatManager), és a válaszvisszahívást. A vezető vezérli az áramlást – itt körkörös váltakozó módon zajlik a váltás meghatározott számú kör esetén.

from semantic_kernel.agents import GroupChatOrchestration, RoundRobinGroupChatManager

agents = get_agents()
group_chat_orchestration = GroupChatOrchestration(
    members=agents,
    manager=RoundRobinGroupChatManager(max_rounds=5),  # Odd number so writer gets the last word
    agent_response_callback=agent_response_callback,
)

A futtatókörnyezet indítása

Indítsa el a futtatókörnyezetet az ügynök működtetésének kezeléséhez.

from semantic_kernel.agents.runtime import InProcessRuntime

runtime = InProcessRuntime()
runtime.start()

Orchestráció meghívása

Hívja meg az orchestrationt az kezdeti feladattal (pl. "Szlogen megalkotása új elektromos SUV-hoz..."). Az ügynökök felváltva válaszolnak, és finomítják az eredményt.

orchestration_result = await group_chat_orchestration.invoke(
    task="Create a slogan for a new electric SUV that is affordable and fun to drive.",
    runtime=runtime,
)

Eredmények gyűjtése

Várjon, amíg az összehangolás befejeződik.

value = await orchestration_result.get()
print(f"***** Final Result *****\n{value}")

Opcionális: A futtatókörnyezet leállítása

A feldolgozás befejezése után állítsa le a futtatókörnyezetet az erőforrások törléséhez.

await runtime.stop_when_idle()

Mintakimenet

**Writer**
"Drive Tomorrow: Affordable Adventure Starts Today!"
**Reviewer**
This slogan, "Drive Tomorrow: Affordable Adventure Starts Today!", effectively communicates the core attributes...
**Writer**
"Embrace the Future: Your Affordable Electric Adventure Awaits!"
**Reviewer**
This revised slogan, "Embrace the Future: Your Affordable Electric Adventure Awaits!", further enhances the message...
**Writer**
"Feel the Charge: Adventure Meets Affordability in Your New Electric SUV!"
***** Result *****
"Feel the Charge: Adventure Meets Affordability in Your New Electric SUV!"

Jótanács

A teljes mintakód itt érhető el.

Megjegyzés:

Az ügynök-vezénylés még nem érhető el a Java SDK-ban.

A Csoportos csevegés-kezelő testreszabása

A csoportos csevegési folyamatot a saját GroupChatManager implementálásával szabhatja testre. Ez lehetővé teszi az eredmények szűrésének, a következő ügynök kiválasztásának, valamint a felhasználói bemenet kérésének vagy a csevegés leállításának szabályozását.

Létrehozhat például egy egyéni kezelőt az absztrakt metódusok GroupChatManager öröklésével és felülírásával:

using Microsoft.SemanticKernel.Agents.Orchestration.GroupChat;
using Microsoft.SemanticKernel.ChatCompletion;
using System.Threading;
using System.Threading.Tasks;

public class CustomGroupChatManager : GroupChatManager
{
    public override ValueTask<GroupChatManagerResult<string>> FilterResults(ChatHistory history, CancellationToken cancellationToken = default)
    {
        // Custom logic to filter or summarize chat results
        return ValueTask.FromResult(new GroupChatManagerResult<string>("Summary") { Reason = "Custom summary logic." });
    }

    public override ValueTask<GroupChatManagerResult<string>> SelectNextAgent(ChatHistory history, GroupChatTeam team, CancellationToken cancellationToken = default)
    {
        // Randomly select an agent from the team
        var random = new Random();
        int index = random.Next(team.Members.Count);
        string nextAgent = team.Members[index].Id;
        return ValueTask.FromResult(new GroupChatManagerResult<string>(nextAgent) { Reason = "Custom selection logic." });
    }

    public override ValueTask<GroupChatManagerResult<bool>> ShouldRequestUserInput(ChatHistory history, CancellationToken cancellationToken = default)
    {
        // Custom logic to decide if user input is needed
        return ValueTask.FromResult(new GroupChatManagerResult<bool>(false) { Reason = "No user input required." });
    }

    public override ValueTask<GroupChatManagerResult<bool>> ShouldTerminate(ChatHistory history, CancellationToken cancellationToken = default)
    {
        // Optionally call the base implementation to check for default termination logic
        var baseResult = base.ShouldTerminate(history, cancellationToken).Result;
        if (baseResult.Value)
        {
            // If the base logic says to terminate, respect it
            return ValueTask.FromResult(baseResult);
        }

        // Custom logic to determine if the chat should terminate
        bool shouldEnd = history.Count > 10; // Example: end after 10 messages
        return ValueTask.FromResult(new GroupChatManagerResult<bool>(shouldEnd) { Reason = "Custom termination logic." });
    }
}

Ezután használhatja az egyéni kezelőt az orchestrationben:

GroupChatOrchestration orchestration = new (new CustomGroupChatManager { MaximumInvocationCount = 5 }, ...);

Jótanács

Az egyéni csoportos csevegéskezelő teljes példája itt érhető el

A csoportos csevegési folyamatot a saját GroupChatManager implementálásával szabhatja testre. Ez lehetővé teszi az eredmények szűrésének, a következő ügynök kiválasztásának, valamint a felhasználói bemenet kérésének vagy a csevegés leállításának szabályozását.

Létrehozhat például egy egyéni kezelőt az absztrakt metódusok GroupChatManager öröklésével és felülírásával:

from semantic_kernel.agents import GroupChatManager, BooleanResult, StringResult, MessageResult
from semantic_kernel.contents import ChatMessageContent, ChatHistory

class CustomGroupChatManager(GroupChatManager):
    async def filter_results(self, chat_history: ChatHistory) -> MessageResult:
        # Custom logic to filter or summarize chat results
        summary = "Summary of the discussion."
        return MessageResult(result=ChatMessageContent(role="assistant", content=summary), reason="Custom summary logic.")

    async def select_next_agent(self, chat_history: ChatHistory, participant_descriptions: dict[str, str]) -> StringResult:
        # Randomly select an agent from the participants
        import random
        next_agent = random.choice(list(participant_descriptions.keys()))
        return StringResult(result=next_agent, reason="Custom selection logic.")

    async def should_request_user_input(self, chat_history: ChatHistory) -> BooleanResult:
        # Custom logic to decide if user input is needed
        return BooleanResult(result=False, reason="No user input required.")

    async def should_terminate(self, chat_history: ChatHistory) -> BooleanResult:
        # Optionally call the base implementation to check for default termination logic
        base_result = await super().should_terminate(chat_history)
        if base_result.result:
            return base_result
        # Custom logic to determine if the chat should terminate
        should_end = len(chat_history.messages) > 10  # Example: end after 10 messages
        return BooleanResult(result=should_end, reason="Custom termination logic.")

Ezután használhatja az egyéni kezelőt az orchestrationben:

from semantic_kernel.agents import GroupChatOrchestration

group_chat_orchestration = GroupChatOrchestration(manager=CustomGroupChatManager(max_rounds=5), ...)

Jótanács

Az egyéni csoportos csevegéskezelő teljes példája itt érhető el

Megjegyzés:

Az ügynök-vezénylés még nem érhető el a Java SDK-ban.

Csoportos csevegéskezelői függvényhívások sorrendje

Csoportos csevegések vezénylésekor a csoportos csevegés-kezelő metódusai a beszélgetés minden egyes köréhez meghatározott sorrendben lesznek meghívva:

  1. ShouldRequestUserInput: Ellenőrzi, hogy szükség van-e felhasználói (emberi) bemenetre a következő ügynök beszéde előtt. Ha igaz, a vezénylés szünetel és vár felhasználói bemenetre. A felhasználói bemenet ezután hozzáadódik a kezelő csevegési előzményeihez, és elküldi az összes ügynöknek.
  2. ShouldTerminate: Meghatározza, hogy a csoportos csevegés befejeződik-e (például, ha eléri a fordulók maximális számát, vagy teljesül egy egyéni feltétel). Ha igaz, az összehangolás az eredményszűrésre lép tovább.
  3. FilterResults: Csak akkor hívható meg, ha a csevegés befejeződött, a beszélgetés végleges eredményeinek összegzéséhez vagy feldolgozásához.
  4. SelectNextAgent: Ha a csevegés nem végződik, kiválasztja a következő ügynököt, aki válaszol a beszélgetésben.

Ez a sorrend biztosítja, hogy a beszélgetés folytatása előtt a felhasználói beviteli és a befejezési feltételek legyenek ellenőrizve, és hogy az eredmények csak a végén legyenek szűrve. Az egyes lépések logikáját úgy szabhatja testre, hogy felülírja a megfelelő metódusokat az egyéni csoportos csevegéskezelőben.

Következő lépések

Handoff Orchestration

  • Last updated on