Az ügynökök közötti együttműködés felfedezése a AgentChat

Fontos

Ez a funkció a kísérleti fázisban van. Az ebben a szakaszban található funkciók fejlesztés alatt állnak, és változhatnak, mielőtt továbblépnek az előzetes verzióra vagy a kiadásra jelölt fázisra.

A jelen vitafórumhoz kapcsolódó részletes API-dokumentáció a következő címen érhető el:

• AgentChat
• AgentGroupChat
• Microsoft.SemanticKernel.Agents.Chat

• AgentChat
• AgentGroupChat

A funkció jelenleg nem érhető el a Javában.

Mi az a AgentChat?

AgentChat olyan keretrendszert biztosít, amely lehetővé teszi több ügynök közötti interakciót, még akkor is, ha különböző típusúak. Ez lehetővé teszi, hogy egy ChatCompletionAgent és egy OpenAIAssistantAgent egy beszélgetésen belül működjenek együtt. AgentChat emellett belépési pontokat is meghatároz az ügynökök közötti együttműködés elindításához, akár több válaszon, akár egyetlen ügynökválaszon keresztül.

Absztrakt osztályként AgentChat alosztályok hozhatók létre a testreszabott forgatókönyvek támogatásához.

Az egyik ilyen alosztály, a AgentGroupChata AgentChatkonkrét megvalósítását kínálja a beszélgetések dinamikájának kezelésére szolgáló stratégiaalapú megközelítéssel.

Egy AgentGroupChat létrehozása

Egy AgentGroupChatlétrehozásához megadhatja a részt vevő ügynököket, vagy létrehozhat egy üres csevegést, majd hozzáadhat ügynök-résztvevőket. Az Chat-Settings és a stratégiák konfigurálása az AgentGroupChat inicializálása során is megtörténik. Ezek a beállítások határozzák meg, hogyan fog működni a beszélgetési dinamika a csoportban.

Megjegyzés: Az alapértelmezett Chat-Settings egyetlen válaszra korlátozott beszélgetést eredményeznek. A csevegési beállítások konfigurálásával kapcsolatos részletekért tekintse meg AgentChat a Viselkedés című témakört.

Hozz létre egy AgentGroupChat a Agentsegítségével:

// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;

// Create chat with participating agents.
AgentGroupChat chat = new(agent1, agent2);

# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)

# Create chat with participating agents
chat = AgentGroupChat(agents=[agent1, agent2])

A funkció jelenleg nem érhető el a Javában.

Agent hozzáadása egy AgentGroupChat-hez:

// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;

// Create an empty chat.
AgentGroupChat chat = new();

// Add agents to an existing chat.
chat.AddAgent(agent1);
chat.AddAgent(agent2);

# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)

# Create an empty chat
chat = AgentGroupChat()

# Add agents to an existing chat
chat.add_agent(agent=agent1)
chat.add_agent(agent=agent2)

A funkció jelenleg nem érhető el a Javában.

Az AgentGroupChat használata

AgentChat két üzemmódot támogat: Single-Turn és Multi-Turn. A single-turnegy adott ügynököt jelöl ki a válasz megadására. A multi-turn-ban a beszélgetés összes ügynöke felváltva válaszol, amíg meg nem teljesül egy befejezési feltétel. Mindkét módban az ügynökök együttműködhetnek úgy, hogy válaszolnak egy másikra egy meghatározott cél elérése érdekében.

Bemenet megadása

Egy bemeneti üzenet hozzáadása egy AgentChat-hoz ugyanazt a mintát követi, mint egy ChatHistory objektum.

AgentGroupChat chat = new();

chat.AddChatMessage(new ChatMessageContent(AuthorRole.User, "<message content>"));

chat = AgentGroupChat()

await chat.add_chat_message(message="<message content>")

A funkció jelenleg nem érhető el a Javában.

Egyfordulós ügynökmeghívás

Többfordulós meghívás esetén a rendszernek el kell döntenie, hogy melyik ügynök válaszol legközelebb, és mikor fejeződjön be a beszélgetés. Ezzel szemben az egyfordulós hívás egyszerűen a megadott ügynök válaszát adja vissza, így a hívó közvetlenül kezelheti az ügynök részvételét.

Miután egy ügynök egyfordulós meghíváson keresztül részt vesz a műveletben AgentChat , a rendszer hozzáadja a többfordulós meghívásra jogosult ügynökök csoportjához.

// Define an agent
ChatCompletionAgent agent = ...;

// Create an empty chat.
AgentGroupChat chat = new();

// Invoke an agent for its response
ChatMessageContent[] messages = await chat.InvokeAsync(agent).ToArrayAsync();

# Define an agent
agent = ChatCompletionAgent(...)

# Create an empty chat
chat = AgentGroupChat()

# Invoke an agent for its response(s)
async for message in chat.invoke(agent)
    # process message response(s)

A funkció jelenleg nem érhető el a Javában.

Több lépéses ügynökhívás

Bár az ügynök-együttműködés megköveteli, hogy egy olyan rendszer legyen érvényben, amely nem csak meghatározza, hogy melyik ügynöknek kell válaszolnia az egyes fordulók során, hanem azt is felméri, hogy a beszélgetés mikor éri el a kívánt célját, a többfordulós együttműködés kezdeményezése továbbra is egyszerű marad.

Az ügynök válaszait a rendszer aszinkron módon adja vissza a létrehozásukkor, így a beszélgetés valós időben bontakozik ki.

Megjegyzés: A következő szakaszokban az ügynök kiválasztása és a csevegés megszüntetése részletesen bemutatja a végrehajtási beállításokat. Az alapértelmezett végrehajtási beállítások szekvenciális vagy ciklikus időszeleteléses kijelölést használnak, és egyetlen fordulóra korlátozzák az ügynökök részvételét.

.NET Végrehajtási beállítások API: AgentGroupChatSettings

// Define agents
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;

// Create chat with participating agents.
AgentGroupChat chat =
  new(agent1, agent2)
  {
    // Override default execution settings
    ExecutionSettings =
    {
        TerminationStrategy = { MaximumIterations = 10 }
    }
  };

// Invoke agents
await foreach (ChatMessageContent response in chat.InvokeAsync())
{
  // Process agent response(s)...
}

# Define agents
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)

# Create chat with participating agents
chat = AgentGroupChat(
    agents=[agent1, agent2],
    termination_strategy=DefaultTerminationStrategy(maximum_iterations=10),
)

async for response in chat.invoke():
    # process agent response(s)

A funkció jelenleg nem érhető el a Javában.

Csevegési előzmények elérése

A AgentChat beszélgetési előzményei mindig elérhetők, annak ellenére, hogy az üzenetek a hívási mintán keresztül érkeznek. Ez biztosítja, hogy a korábbi kölcsönhatások elérhetők maradjanak a beszélgetés során.

Megjegyzés: Először a legújabb üzenetet adja meg (csökkenő sorrendben: legújabbtól a legrégebbiig).

// Define and use a chat
AgentGroupChat chat = ...;

// Access history for a previously utilized AgentGroupChat
ChatMessageContent[] history = await chat.GetChatMessagesAsync().ToArrayAsync();

# Define a group chat
chat = AgentGroupChat(...)

# Access history for a previously utilized AgentGroupChat
history = await chat.get_chat_messages()

A funkció jelenleg nem érhető el a Javában.

Mivel a különböző ügynöktípusok vagy konfigurációk megőrizhetik a beszélgetési előzmények saját verzióját, az ügynökspecifikus előzmények is elérhetők egy ügynök megadásával. (Például: OpenAIAssistant és ChatCompletionAgent.)

// Agents to participate in chat
ChatCompletionAgent agent1 = ...;
OpenAIAssistantAgent agent2 = ...;

// Define a group chat
AgentGroupChat chat = ...;

// Access history for a previously utilized AgentGroupChat
ChatMessageContent[] history1 = await chat.GetChatMessagesAsync(agent1).ToArrayAsync();
ChatMessageContent[] history2 = await chat.GetChatMessagesAsync(agent2).ToArrayAsync();

# Agents to participate in a chat
agent1 = ChatCompletionAgent(...)
agent2 = OpenAIAssistantAgent(...)

# Define a group chat
chat = AgentGroupChat(...)

# Access history for a previously utilized AgentGroupChat
history1 = await chat.get_chat_messages(agent=agent1)
history2 = await chat.get_chat_messages(agent=agent2)

A funkció jelenleg nem érhető el a Javában.

AgentGroupChat viselkedésének meghatározása

Az ügynökök közötti együttműködés az összetett feladatok megoldásához alapvető ügynöki minta. A minta hatékony használatához olyan rendszert kell létrehozni, amely nem csak meghatározza, hogy melyik ügynöknek kell válaszolnia az egyes fordulók során, hanem azt is felméri, hogy a beszélgetés mikor éri el a kívánt célját. Ehhez kezelni kell az ügynökök kiválasztását, és egyértelmű kritériumokat kell létrehozni a beszélgetések befejezéséhez, biztosítva az ügynökök közötti zökkenőmentes együttműködést a megoldás felé. Mindkét szempontot a Végrehajtási beállítások tulajdonság szabályozza.

Az alábbi szakaszok, az ügynökválasztás és a csevegés megszüntetése részletesen ismertetik ezeket a szempontokat.

Ügynök kiválasztása

Többfordulós meghívás esetén az ügynökválasztást egy kiválasztási stratégia vezérli. Ezt a stratégiát egy alaposztály határozza meg, amely kiterjeszthető az adott igényekre szabott egyéni viselkedések implementálásához. A kényelem érdekében két előre meghatározott konkrét kiválasztási stratégia is rendelkezésre áll, amelyek használatra kész megközelítéseket kínálnak az ügynökök kiválasztásának kezelésére a beszélgetések során.

Ha ismert, megadható egy kezdeti ügynök, hogy mindig az első lépést tegye meg. Előzménycsökkentőt is használhat a tokenek használatának korlátozására egy KernelFunction-ra alapuló stratégia alkalmazásakor.

.NET Kiválasztási Stratégia API

• SelectionStrategy
• SequentialSelectionStrategy
• KernelFunctionSelectionStrategy

// Define the agent names for use in the function template
const string WriterName = "Writer";
const string ReviewerName = "Reviewer";

// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;

// Create the agents
ChatCompletionAgent writerAgent =
    new()
    {
        Name = WriterName,
        Instructions = "<writer instructions>",
        Kernel = kernel
    };

ChatCompletionAgent reviewerAgent =
    new()
    {
        Name = ReviewerName,
        Instructions = "<reviewer instructions>",
        Kernel = kernel
    };

// Define a kernel function for the selection strategy
KernelFunction selectionFunction =
    AgentGroupChat.CreatePromptFunctionForStrategy(
        $$$"""
        Determine which participant takes the next turn in a conversation based on the the most recent participant.
        State only the name of the participant to take the next turn.
        No participant should take more than one turn in a row.

        Choose only from these participants:
        - {{{ReviewerName}}}
        - {{{WriterName}}}

        Always follow these rules when selecting the next participant:
        - After {{{WriterName}}}, it is {{{ReviewerName}}}'s turn.
        - After {{{ReviewerName}}}, it is {{{WriterName}}}'s turn.

        History:
        {{$history}}
        """,
        safeParameterNames: "history");

// Define the selection strategy
KernelFunctionSelectionStrategy selectionStrategy = 
  new(selectionFunction, kernel)
  {
      // Always start with the writer agent.
      InitialAgent = writerAgent,
      // Parse the function response.
      ResultParser = (result) => result.GetValue<string>() ?? WriterName,
      // The prompt variable name for the history argument.
      HistoryVariableName = "history",
      // Save tokens by not including the entire history in the prompt
      HistoryReducer = new ChatHistoryTruncationReducer(3),
  };   

// Create a chat using the defined selection strategy.
AgentGroupChat chat =
    new(writerAgent, reviewerAgent)
    {
        ExecutionSettings = new() { SelectionStrategy = selectionStrategy }
    };

Python kiválasztási stratégia API:

• SelectionStrategy Alaposztály
• SequentialSelectionStrategy
• KernelFunctionSelectionStrategy

REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"

agent_reviewer = ChatCompletionAgent(
    kernel=kernel,
    name=REVIEWER_NAME,
    instructions="<instructions>",
)

agent_writer = ChatCompletionAgent(
    kernel=kernel,
    name=WRITER_NAME,
    instructions="<instructions>",
)

selection_function = KernelFunctionFromPrompt(
    function_name="selection",
    prompt=f"""
    Determine which participant takes the next turn in a conversation based on the the most recent participant.
    State only the name of the participant to take the next turn.
    No participant should take more than one turn in a row.

    Choose only from these participants:
    - {REVIEWER_NAME}
    - {WRITER_NAME}

    Always follow these rules when selecting the next participant:
    - After user input, it is {WRITER_NAME}'s turn.
    - After {WRITER_NAME} replies, it is {REVIEWER_NAME}'s turn.
    - After {REVIEWER_NAME} provides feedback, it is {WRITER_NAME}'s turn.

    History:
    {{{{$history}}}}
    """,
)

chat = AgentGroupChat(
    agents=[agent_writer, agent_reviewer],
    selection_strategy=KernelFunctionSelectionStrategy(
        function=selection_function,
        kernel=_create_kernel_with_chat_completion("selection"),
        result_parser=lambda result: str(result.value[0]) if result.value is not None else COPYWRITER_NAME,
        agent_variable_name="agents",
        history_variable_name="history",
    ),
)

A funkció jelenleg nem érhető el a Javában.

Csevegés leállítása

Többfordulós hívás esetén a lezárási stratégia határozza meg, hogy mikor kerül sor az utolsó fordulóra. Ez a stratégia biztosítja, hogy a beszélgetés a megfelelő ponton végződik.

Ezt a stratégiát egy alaposztály határozza meg, amely kiterjeszthető az adott igényekre szabott egyéni viselkedések implementálásához. A kényelem érdekében számos előre meghatározott konkrét kiválasztási stratégia is rendelkezésre áll, amelyek használatra kész megközelítéseket kínálnak a AgentChat beszélgetések befejezési feltételeinek meghatározásához.

.NET-megszüntetési stratégia API:

• TerminationStrategy
• RegexTerminationStrategy
• KernelFunctionSelectionStrategy
• KernelFunctionTerminationStrategy
• AggregatorTerminationStrategy

// Initialize a Kernel with a chat-completion service
Kernel kernel = ...;

// Create the agents
ChatCompletionAgent writerAgent =
    new()
    {
        Name = "Writer",
        Instructions = "<writer instructions>",
        Kernel = kernel
    };

ChatCompletionAgent reviewerAgent =
    new()
    {
        Name = "Reviewer",
        Instructions = "<reviewer instructions>",
        Kernel = kernel
    };

// Define a kernel function for the selection strategy
KernelFunction terminationFunction =
    AgentGroupChat.CreatePromptFunctionForStrategy(
        $$$"""
        Determine if the reviewer has approved.  If so, respond with a single word: yes

        History:
        {{$history}}
        """,
        safeParameterNames: "history");

// Define the termination strategy
KernelFunctionTerminationStrategy terminationStrategy = 
  new(terminationFunction, kernel)
  {
      // Only the reviewer may give approval.
      Agents = [reviewerAgent],
      // Parse the function response.
      ResultParser = (result) => 
        result.GetValue<string>()?.Contains("yes", StringComparison.OrdinalIgnoreCase) ?? false,
      // The prompt variable name for the history argument.
      HistoryVariableName = "history",
      // Save tokens by not including the entire history in the prompt
      HistoryReducer = new ChatHistoryTruncationReducer(1),
      // Limit total number of turns no matter what
      MaximumIterations = 10,
};

// Create a chat using the defined termination strategy.
AgentGroupChat chat =
    new(writerAgent, reviewerAgent)
    {
        ExecutionSettings = new() { TerminationStrategy = terminationStrategy }
    };

Python-megszüntetési stratégia API:

• TerminationStrategy Alaposztály
• KernelFunctionTerminationStrategy
• AggregatorTerminationStrategy

REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"

agent_reviewer = ChatCompletionAgent(
    kernel=kernel,
    name=REVIEWER_NAME,
    instructions="<instructions>",
)

agent_writer = ChatCompletionAgent(
    kernel=kernel,
    name=WRITER_NAME,
    instructions="<instructions>",
)

termination_function = KernelFunctionFromPrompt(
    function_name="termination",
    prompt="""
    Determine if the copy has been approved.  If so, respond with a single word: yes

    History:
    {{$history}}
    """,
)

chat = AgentGroupChat(
    agents=[agent_writer, agent_reviewer],
    termination_strategy=KernelFunctionTerminationStrategy(
        agents=[agent_reviewer],
        function=termination_function,
        kernel=_create_kernel_with_chat_completion("termination"),
        result_parser=lambda result: str(result.value[0]).lower() == "yes",
        history_variable_name="history",
        maximum_iterations=10,
    ),
)

A funkció jelenleg nem érhető el a Javában.

Csevegés befejezésének állapotának visszaállítása

Függetlenül attól, hogy az egyfordulós vagy többfordulós megközelítéssel van-e AgentGroupChat meghívva, a rendszer frissíti az AgentGroupChat állapotot annak jelzésére, hogy a befejezési feltételek teljesülése után befejeződik. Ez biztosítja, hogy a rendszer felismerje, ha egy beszélgetés teljesen befejeződött. Ahhoz, hogy egy AgentGroupChat példányt továbbra is használni lehessen, miután elérte a Befejezett állapotot, ezt az állapotot vissza kell állítani a további interakciók érdekében. Alaphelyzetbe állítás nélkül további interakciók vagy ügynökválaszok nem lesznek lehetségesek.

Többfordulós hívás esetén, amikor eléri a maximális turn limitet, a rendszer leállítja az ügynök hívását, de nem jelöli befejezettként az adott példányt. Ez lehetővé teszi a beszélgetés meghosszabbítását anélkül, hogy alaphelyzetbe kellene állítania a befejezési állapotot.

// Define an use chat
AgentGroupChat chat = ...;

// Evaluate if completion is met and reset.
if (chat.IsComplete) 
{
  // Opt to take action on the chat result...

  // Reset completion state to continue use
  chat.IsComplete = false;
}

# Define a group chat
chat = AgentGroupChat()

# Evaluate if completion is met and reset
if chat.is_complete:
    # Reset completion state to continue use
    chat.is_complete = False

A funkció jelenleg nem érhető el a Javában.

Teljes beszélgetési állapot törlése

Ha befejezte egy AgentChat használatát, ahol egy OpenAIAssistant részt vett, előfordulhat, hogy törölnie kell a segédhez társított távoli szálat. AgentChat Támogatja a teljes beszélgetési állapot alaphelyzetbe állítását vagy törlését, amely magában foglalja a távoli száldefiníciók törlését is. Ez biztosítja, hogy a csevegés befejezése után az asszisztenssel ne maradjon összekapcsolva bármilyen megmaradt beszélgetési adat.

A teljes visszaállítás nem távolítja el azokat az ügynököket, amelyek csatlakoztak a AgentChat , és a AgentChat-t olyan állapotban hagyja, amely lehetővé teszi annak újrafelhasználását. Ez lehetővé teszi ugyanazokkal az ügynökökkel folytatott interakciók folytatását anélkül, hogy újra kellene őket újrainicializálni, ami hatékonyabbá teszi a jövőbeli beszélgetéseket.

// Define an use chat
AgentGroupChat chat = ...;

// Clear the all conversation state
await chat.ResetAsync();

# Define a group chat
chat = AgentGroupChat()

# Clear the conversation state
await chat.reset()

A funkció jelenleg nem érhető el a Javában.

Útmutató

A teljes körű példáért arról, hogyan használd a AgentGroupChat a Agent együttműködéshez, lásd:

• Az ügynökök együttműködésének koordinálása AgentGroupChat