Eksplorowanie współpracy agenta w czacie agenta (eksperymentalne)

Artykuł
11/03/2024

Ostrzeżenie

Struktura agenta jądra semantycznego jest eksperymentalna, nadal w programowania i może ulec zmianie.

Szczegółowa dokumentacja interfejsu API związana z tą dyskusją jest dostępna pod adresem:

Co to jest czat agenta?

Czat agenta udostępnia platformę, która umożliwia interakcję między wieloma agentami, nawet jeśli są one różnego typu. Dzięki temu agent uzupełniania czatu i agent open AI Assistant współpracują ze sobą w ramach tej samej konwersacji. Czat agenta definiuje również punkty wejścia do inicjowania współpracy między agentami, niezależnie od tego, czy za pośrednictwem wielu odpowiedzi, czy jednej odpowiedzi agenta.

Jako klasa abstrakcyjna czat agenta może być podklasowany w celu obsługi scenariuszy niestandardowych.

Jedna z takich podklas, Agent Group Chat, oferuje konkretną implementację czatu agenta przy użyciu podejścia opartego na strategii do zarządzania dynamiką konwersacji.

Tworzenie czatu grupy agentów

Aby utworzyć czat grupy agentów, możesz określić uczestniczących agentów lub utworzyć pusty czat, a następnie dodać uczestników agenta. Konfigurowanie ustawień czatu i strategii jest również wykonywane podczas inicjowania czatu grupy agentów. Te ustawienia definiują sposób działania dynamiki konwersacji w grupie.

Tworzenie czatu grupy agentów przy użyciu agentów:

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

Dodawanie agentów do czatu grupy agentów:

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

Korzystanie z czatu grupy agentów

Czat agenta obsługuje dwa tryby operacji: single-Turn i Multi-Turn. W trybie jednokrotnym określony agent jest wyznaczony do dostarczenia odpowiedzi. W wielu krokach wszyscy agenci w konwersacji reagują na zmianę, dopóki kryterium zakończenia nie zostanie spełnione. W obu trybach agenci mogą współpracować, odpowiadając sobie nawzajem, aby osiągnąć zdefiniowany cel.

Podawanie danych wejściowych

Dodanie komunikatu wejściowego do czatu agenta jest zgodne z tym samym wzorcem co obiekt Historia czatu.

AgentGroupChat chat = new();

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

chat = AgentGroupChat()

await chat.add_chat_message(ChatMessageContent(role=AuthorRole.USER, content="<message content>"))

Wywołanie agenta jednokrotnego

W wywołaniu wieloeściowym system musi zdecydować, który agent odpowiada dalej, a kiedy konwersacja powinna zostać zakończona. Natomiast wywołanie jednokrotne po prostu zwraca odpowiedź od określonego agenta, dzięki czemu obiekt wywołujący może bezpośrednio zarządzać udziałem agenta.

Gdy agent uczestniczy w czacie agenta za pośrednictwem wywołania jednokrotnego, jest dodawany do zestawu agentów uprawnionych do wywołania wielowrotnego.

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

Wywołanie agenta z wieloma zakrętami

Mimo że współpraca agentów wymaga, aby system był w miejscu, który nie tylko określa, który agent powinien reagować podczas każdego kroku, ale także ocenia, kiedy konwersacja osiągnęła zamierzony cel, inicjowanie współpracy wieloeściowej pozostaje proste.

Odpowiedzi agenta są zwracane asynchronicznie w miarę ich generowania, co pozwala na rozwijanie konwersacji w czasie rzeczywistym.

Interfejs API ustawień wykonywania platformy .NET: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)

Uzyskiwanie dostępu do historii czatów

Historia konwersacji czatu agenta jest zawsze dostępna, mimo że wiadomości są dostarczane za pośrednictwem wzorca wywołania. Dzięki temu wcześniejsze wymiany pozostaną dostępne w trakcie konwersacji.

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

Ponieważ różne typy agentów lub konfiguracje mogą obsługiwać własną wersję historii konwersacji, historia specyficzna dla agenta jest również dostępna przez spekulowanie agenta. (Na przykład: Otwórz Asystenta sztucznej inteligencji a agenta uzupełniania czatu).

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

Definiowanie zachowania czatu grupy agentów

Współpraca między agentami w celu rozwiązywania złożonych zadań jest podstawowym wzorcem agenta. Aby skutecznie używać tego wzorca, system musi mieć miejsce, aby nie tylko określić, który agent powinien reagować podczas każdego kolei, ale także ocenia, kiedy konwersacja osiągnęła zamierzony cel. Wymaga to zarządzania wyborem agentów i ustanawiania jasnych kryteriów zakończenia konwersacji, zapewniając bezproblemową współpracę między agentami w kierunku rozwiązania. Oba te aspekty podlegają właściwości Ustawienia wykonywania.

Poniższe sekcje, Wybór agenta i Zakończenie rozmowy, szczegółowo omówią te zagadnienia.

Wybór agenta

W wielu wywołaniach wybór agenta jest kierowany przez strategię wyboru. Ta strategia jest definiowana przez klasę bazową, którą można rozszerzyć w celu zaimplementowania niestandardowych zachowań dostosowanych do określonych potrzeb. Dla wygody dostępne są również dwie wstępnie zdefiniowane konkretne strategie wyboru, oferując gotowe do użycia metody obsługi wyboru agenta podczas konwersacji.

Jeśli jest znany, można określić początkowego agenta, aby zawsze podjąć pierwszy obrót. Można również użyć reduktora historii w celu ograniczenia użycia tokenów podczas korzystania ze strategii opartej na funkcji jądra.

Interfejs API strategii wyboru platformy .NET:

// 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(
    service_id=REVIEWER_NAME,
    kernel=kernel,
    name=REVIEWER_NAME,
    instructions="<instructions>",
)

agent_writer = ChatCompletionAgent(
    service_id=WRITER_NAME,
    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",
    ),
)

Zakończenie rozmowy

W wieloetatowym wywołaniu strategia zakończenia określa, kiedy ma miejsce ostateczna kolej. Ta strategia zapewnia zakończenie konwersacji w odpowiednim momencie.

Ta strategia jest definiowana przez klasę bazową, którą można rozszerzyć w celu zaimplementowania niestandardowych zachowań dostosowanych do określonych potrzeb. Dla wygody dostępne są również wstępnie zdefiniowane wstępnie określone strategie wyboru, oferując gotowe do użycia podejścia do definiowania kryteriów zakończenia konwersacji czatu agenta.

Interfejs API strategii wyboru platformy .NET:

// 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(
    service_id=REVIEWER_NAME,
    kernel=kernel,
    name=REVIEWER_NAME,
    instructions="<instructions>",
)

agent_writer = ChatCompletionAgent(
    service_id=WRITER_NAME,
    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,
    ),
)

Resetowanie stanu ukończenia czatu

Niezależnie od tego, czy czat grupy agentów jest wywoływany przy użyciu podejścia jednokrotnego lub wieloetkowego, stan czatu grupy agentów jest aktualizowany w celu wskazania, że zostanie ukończony po spełnieniu kryteriów zakończenia. Dzięki temu system rozpoznaje, kiedy konwersacja została w pełni zakończona. Aby nadal korzystać z wystąpienia czatu grupy agentów po osiągnięciu stanu Ukończono , ten stan musi zostać zresetowany, aby umożliwić dalsze interakcje. Bez resetowania nie będzie możliwe dodatkowe interakcje lub odpowiedzi agenta.

W przypadku wywołania wieloesięgowego, które osiągnie maksymalny limit kolei, system przestanie wywołać agenta, ale nie oznaczy wystąpienia jako ukończone. Pozwala to na możliwość rozszerzenia konwersacji bez konieczności resetowania stanu ukończenia .

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

Wyczyść stan pełnej konwersacji

Po zakończeniu korzystania z czatu agenta, w którym uczestniczył Asystent open AI, może być konieczne usunięcie zdalnego wątku skojarzonego z asystentem. Czat agenta obsługuje resetowanie lub czyszczenie całego stanu konwersacji, co obejmuje usuwanie dowolnej definicji wątku zdalnego. Gwarantuje to, że po zakończeniu czatu żadne pozostałe dane konwersacji nie pozostają połączone z asystentem.

Pełne resetowanie nie powoduje usunięcia agentów , którzy dołączyli do czatu agenta i opuszcza czat agenta w stanie, w którym można go ponownie użyć. Pozwala to na kontynuację interakcji z tymi samymi agentami bez konieczności ponownego inicjowania ich, co zwiększa wydajność przyszłych rozmów.

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

Instrukcje

Aby zapoznać się z kompleksowego przykładu użycia czatu grupy agentów na potrzeby współpracy agenta , zobacz:

Jak koordynować współpracę agenta przy użyciu czatu grupy agentów

Tworzenie agenta na podstawie szablonu

Udostępnij za pośrednictwem