Freigeben über

Erforschung der Zusammenarbeit von Agenten in AgentChat

  • Artikel

Wichtig

Dieses Feature befindet sich in der experimentellen Phase. Features in dieser Phase befinden sich noch in der Entwicklung und können sich ändern, bevor sie zur Vorschau- oder Veröffentlichungskandidatenstufe wechseln.

Detaillierte API-Dokumentation zu dieser Diskussion finden Sie unter:

Agents sind derzeit in Java nicht verfügbar.

Was ist AgentChat?

AgentChat bietet ein Framework, das die Interaktion zwischen mehreren Agents ermöglicht, auch wenn sie von unterschiedlichen Typen sind. Dies ermöglicht es, dass ein ChatCompletionAgent und ein OpenAIAssistantAgent innerhalb derselben Unterhaltung zusammenarbeiten. AgentChat definiert auch Einstiegspunkte zum Initiieren der Zusammenarbeit zwischen Agents, ob über mehrere Antworten oder eine einzelne Agentantwort.

Als abstrakte Klasse können AgentChat unterklassigt werden, um benutzerdefinierte Szenarien zu unterstützen.

Eine solche Unterklasse, AgentGroupChat, bietet eine konkrete Implementierung von AgentChatunter Verwendung eines strategiebasierten Ansatzes zur Steuerung der Gesprächsdynamik.

Erstellen eines AgentGroupChat

Um eine AgentGroupChatzu erstellen, können Sie entweder die teilnehmenden Agenten angeben oder einen leeren Chat erstellen und anschließend Agent-Teilnehmer hinzufügen. Die Konfiguration der Chateinstellungen und der Strategien wird auch während der AgentGroupChat Initialisierung durchgeführt. Diese Einstellungen definieren, wie die Gesprächsdynamik innerhalb der Gruppe wirken wird.

Hinweis: Die Standardmäßigen Chateinstellungen führen zu einer Unterhaltung, die auf eine einzelne Antwort beschränkt ist. Ausführliche Informationen zum Konfigurieren von _Chat-Einstellungen finden Sie unter AgentChat Behavior.

Erstellung eines AgentGroupChat mit Agent.

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

Agents sind derzeit in Java nicht verfügbar.

Hinzufügen eines Agent zu einem AgentGroupChat:

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

Agents sind derzeit in Java nicht verfügbar.

Verwendung von AgentGroupChat

AgentChat unterstützt zwei Betriebsmodi: Single-Turn und Multi-Turn. In single-turnwird ein bestimmter Agent dafür benannt, eine Antwort zu geben. In multi-turnwechseln sich alle Agenten im Gespräch ab, zu antworten, bis ein Beendigungskriterium erfüllt ist. In beiden Modi können Agents zusammenarbeiten, indem sie auf ein definiertes Ziel reagieren.

Bereitstellen von Eingaben

Das Hinzufügen einer Eingabenachricht zu einem AgentChat folgt demselben Muster wie bei einem ChatHistory-Objekt.

AgentGroupChat chat = new();

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

chat = AgentGroupChat()

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

Agents sind derzeit in Java nicht verfügbar.

Aufruf des Agenten für einen einzelnen Durchgang

Bei einem Multi-Turn-Aufruf muss das System entscheiden, welcher Agent als Nächstes antwortet und wann die Unterhaltung beendet werden soll. Im Gegensatz dazu liefert ein Single-Turn-Aufruf einfach eine Rückmeldung des entsprechenden Agents, sodass der Anrufer die Agentbeteiligung direkt steuern kann.

Nachdem ein Agent durch eine einmalige Aufforderung an der AgentChat teilnimmt, wird er dem Bereich von Agenten hinzugefügt, die für Mehrfachaufrufe berechtigt sind.

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

Agents sind derzeit in Java nicht verfügbar.

Aufruf eines Mehrdurchlauf-Agenten

Während die Agentzusammenarbeit erfordert, dass ein System vorhanden sein muss, das nicht nur bestimmt, welcher Agent während jeder Reihe reagieren soll, sondern auch bewertet, wann die Unterhaltung ihr beabsichtigtes Ziel erreicht hat, bleibt das Initiieren der mehrstufigen Zusammenarbeit einfach.

Agentantworten werden asynchron zurückgegeben, während sie generiert werden, sodass sich die Unterhaltung in Echtzeit entfalten kann.

Hinweis: In den folgenden Abschnitten wird die Agentauswahl und die Beendigung des Chats ausführlich in die Ausführungseinstellungen eingetaucht. Die Standard-Execution Settings verwenden sequenzielle oder Round-Robin-Auswahl und beschränken die Agentbeteiligung auf eine einzelne Runde.

.NET-Ausführungseinstellungen-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)

Agenten sind derzeit nicht in Java verfügbar.

Zugreifen auf den Chatverlauf

Auf den AgentChat Gesprächsverlauf kann immer zugegriffen werden, selbst wenn Nachrichten über das Aufrufmuster übermittelt werden. Dadurch wird sichergestellt, dass vergangene Austausch während der gesamten Unterhaltung verfügbar bleiben.

Hinweis: Die neueste Nachricht wird zuerst bereitgestellt (absteigende Reihenfolge: neueste bis älteste).

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

Agents sind derzeit in Java nicht verfügbar.

Da verschiedene Agenttypen oder -konfigurationen möglicherweise ihre eigene Version des Unterhaltungsverlaufs beibehalten können, ist der agentspezifische Verlauf auch verfügbar, indem ein Agent angegeben wird. (Beispiel: OpenAIAssistant im Vergleich zu 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)

Agents sind derzeit in Java nicht verfügbar.

Definition des AgentGroupChat-Verhaltens

Die Zusammenarbeit zwischen Agents zur Lösung komplexer Aufgaben ist ein zentrales agentisches Muster. Um dieses Muster effektiv zu verwenden, muss ein System vorhanden sein, das nicht nur bestimmt, welcher Agent während jeder Drehung reagieren soll, sondern auch bewertet, wenn die Unterhaltung ihr beabsichtigtes Ziel erreicht hat. Dies erfordert die Verwaltung der Agentauswahl und die Festlegung klarer Kriterien für die Beendigung von Unterhaltungen, um eine nahtlose Zusammenarbeit zwischen den Agenten zu einer Lösung sicherzustellen. Beide Aspekte unterliegen der Eigenschaft "Ausführungseinstellungen" .

In den folgenden Abschnitten, agent Selection and Chat Termination, werden diese Überlegungen ausführlich erläutert.

Agent-Auswahl

Bei mehrstufigen Aufrufen wird die Agentauswahl durch eine Auswahlstrategie gesteuert. Diese Strategie wird durch eine Basisklasse definiert, die erweitert werden kann, um benutzerdefinierte Verhaltensweisen zu implementieren, die auf bestimmte Anforderungen zugeschnitten sind. Zur Vereinfachung stehen auch zwei vordefinierte konkrete Auswahlstrategien zur Verfügung, die einsatzbereite Ansätze für die Behandlung der Agentauswahl während Unterhaltungen bieten.

Wenn bekannt, kann ein Erstagent angegeben werden, um immer den ersten Zug zu machen. Ein Verlaufsminderer kann auch verwendet werden, um die Tokennutzung zu begrenzen, wenn eine Strategie auf der Grundlage einer KernelFunctionverwendet wird.

.NET Auswahlstrategie-API:

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

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

Agents sind derzeit in Java nicht verfügbar.

Beendigung des Chats

Beim Multi-Turn-Aufruf bestimmt die Termination Strategy, wann der endgültige Schritt stattfindet. Diese Strategie stellt sicher, dass die Unterhaltung an dem entsprechenden Punkt endet.

Diese Strategie wird durch eine Basisklasse definiert, die erweitert werden kann, um benutzerdefinierte Verhaltensweisen zu implementieren, die auf bestimmte Anforderungen zugeschnitten sind. Zur Vereinfachung stehen auch mehrere vordefinierte konkrete Auswahlstrategien zur Verfügung, die einsatzbereite Ansätze zum Definieren von Beendigungskriterien für eine AgentChat Unterhaltungen bieten.

.NET Selection Strategy API:

// 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(selectionFunction, 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 }
    };


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

Agents sind derzeit in Java nicht verfügbar.

Zurücksetzen des Chat-Abschlussstatus

Unabhängig davon, ob AgentGroupChat mithilfe des Single-Turn- oder Multi-Turn-Ansatzes aufgerufen wird, wird der Status der AgentGroupChat aktualisiert, um anzugeben, dass es abgeschlossen ist, sobald die Beendigungskriterien erfüllt sind. Dadurch wird sichergestellt, dass das System erkennt, wann eine Unterhaltung vollständig abgeschlossen wurde. Um eine AgentGroupChat Instanz weiterhin zu verwenden, nachdem sie den Status Abgeschlossen erreicht hat, muss dieser Zustand zurückgesetzt werden, um weitere Interaktionen zuzulassen. Ohne Zurücksetzen sind zusätzliche Interaktionen oder Agentantworten nicht möglich.

Bei einem Multi-Turn-Aufruf, der den maximalen Turngrenzwert erreicht, wird der Aufruf des Agents beendet, die Instanz wird jedoch nicht als abgeschlossen markiert. Dies ermöglicht die Möglichkeit, die Unterhaltung zu erweitern, ohne den Status " Abschluss" zurückzusetzen.

// 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

Derzeit sind Agents in Java nicht verfügbar.

Zustand des kompletten Gesprächs löschen

Wenn Sie mit einer AgentChat fertig sind, an der ein OpenAIAssistant teilgenommen hat, kann es erforderlich sein, den remote Thread dem -Assistenten zugeordnetenzu löschen. AgentChat unterstützt das Zurücksetzen oder Löschen des gesamten Unterhaltungszustands, einschließlich der Löschung jeder Remote--Thread--Definition. Dadurch wird sichergestellt, dass am Ende des Chats keine Restgesprächsdaten mit dem Assistenten verknüpft bleiben.

Eine vollständige Zurücksetzung entfernt die Agents nicht, die dem AgentChat beigetreten waren, und belässt die AgentChat in einem Zustand, in dem sie wiederverwendet werden kann. Dies ermöglicht die Fortsetzung von Interaktionen mit denselben Agents, ohne sie erneut zu initialisieren und zukünftige Unterhaltungen effizienter zu gestalten.

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

Agents sind derzeit in Java nicht verfügbar.

Vorgehensweise

Ein durchgängiges Beispiel zur Nutzung von AgentGroupChat zur Agent-Zusammenarbeit finden Sie unter:

Erstellen eines Agents aus einer Vorlage