Understanding Agent Group Chat

Oct 13, 2025 by thesweetdesigns.com 138 views

Introduction

In this article, we will explore the process of creating an agent group chat feature in Semantic Kernel. We will discuss the challenges of implementing this feature and provide a step-by-step guide on how to create a basic agent group chat using Semantic Kernel.

Understanding Agent Group Chat

Agent group chat is a feature that allows multiple agents to interact with each other in a conversation. Each agent has a specific role and responsibility, and they work together to achieve a common goal. In the context of Semantic Kernel, agent group chat is implemented using the AgentGroupChat class.

Challenges of Implementing Agent Group Chat

Implementing agent group chat in Semantic Kernel can be challenging due to the following reasons:

Complexity of Agent Interactions: Agent group chat involves multiple agents interacting with each other, which can lead to complex conversations and conflicts.
Agent Roles and Responsibilities: Each agent has a specific role and responsibility, which can be difficult to manage and coordinate.
Termination and Selection Strategies: Agent group chat requires termination and selection strategies to determine when the conversation is complete and which agent should take the next turn.

Step-by-Step Guide to Creating Agent Group Chat

To create a basic agent group chat using Semantic Kernel, follow these steps:

Step 1: Define Agent Roles and Responsibilities

Define the roles and responsibilities of each agent in the conversation. In this example, we have three agents: Reviewer, Writer, and Saver.

REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"
SAVER_NAME = "Saver"

Step 2: Create Agent Instances

Create instances of the ChatCompletionAgent class for each agent.

agent_reviewer = ChatCompletionAgent(
    kernel=kernel,
    name=REVIEWER_NAME,
    instructions="""
Your responsibility is to review and identify how to improve user-provided content.
If the user has provided input or direction for content already provided, specify how to address this input.
Never directly perform the correction or provide an example.
Once the content has been updated in a subsequent response, review it again until it is satisfactory.

RULES:
- Only identify suggestions that are specific and actionable.
- Verify previous suggestions have been addressed.
- Never repeat previous suggestions.
""",
)

agent_writer = ChatCompletionAgent(
    kernel=kernel,
    name=WRITER_NAME,
    instructions="""
Your sole responsibility is to rewrite content according to review suggestions.
- Always apply all review directions.
- Always revise the content in its entirety without explanation.
- Never address the user.
""",
)

agent_saver = ChatCompletionAgent(
    kernel=kernel,
    name=SAVER_NAME,
    arguments=KernelArguments(settings=settings),
    instructions=f"""
Your responsibility is to save the final reviewed content.
- Always take the last content generated by {WRITER_NAME}.
- Call the function `save_to_file` with the content.
- Confirm once the content is saved.
""",
)

Step 3: Define Selection and Termination Strategies

Define the selection and termination strategies for the agent group chat.

selection_function = KernelFunctionFromPrompt(
    function_name="selection",
    prompt=f"""
Examine the provided RESPONSE and choose the next participant.
State only the name of the chosen participant without explanation.
Never choose the participant named in the RESPONSE.

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

Rules:
- If RESPONSE is user input, it is {REVIEWER_NAME}'s turn.
- If RESPONSE is by {REVIEWER_NAME}, it is {WRITER_NAME}'s turn.
- If RESPONSE is by {WRITER_NAME}, it is {SAVER_NAME}'s turn.
- If RESPONSE is by {SAVER_NAME}, the process is complete.

RESPONSE:
{{{{$lastmessage}}}}
""",
)

termination_function = KernelFunctionFromPrompt(
    function_name="termination",
    prompt=f"""
Examine the RESPONSE and determine whether the content has been saved.
If the content has been saved, respond with a single word without explanation: {termination_keyword}.

RESPONSE:
{{{{$lastmessage}}}}
""",
)

Step 4: Create Agent Group Chat Instance

Create an instance of the AgentGroupChat class with the defined agents, selection strategy, and termination strategy.

chat = AgentGroupChat(
    agents=[agent_reviewer, agent_writer, agent_saver],
    selection_strategy=KernelFunctionSelectionStrategy(
        initial_agent=agent_reviewer,
        function=selection_function,
        kernel=kernel,
        result_parser=lambda result: str(result.value[0]).strip() if result.value[0] is not None else WRITER_NAME,
        history_variable_name="lastmessage",
        history_reducer=history_reducer,
    ),
    termination_strategy=KernelFunctionTerminationStrategy(
        agents=[agent_saver],
        function=termination_function,
        kernel=kernel,
        result_parser=lambda result: termination_keyword in str(result.value[0]).lower(),
        history_variable_name="lastmessage",
        maximum_iterations=10,
        history_reducer=history_reducer,
    ),
)

Step 5: Run the Agent Group Chat

Run the agent group chat by calling the invoke method on the AgentGroupChat instance.

async for response in chat.invoke():
    if response is None or not response.name:
        continue
    print()
    print(f"# {response.name.upper()}:\n{response.content}")

Conclusion

In this article, we explored the process of creating an agent group chat feature in Semantic Kernel. We discussed the challenges of implementing this feature and provided a step-by-step guide on how to create a basic agent group chat using Semantic Kernel. By following these steps, you can create a basic agent group chat and experiment with different agent roles, responsibilities, and strategies.

Code

import asyncio
import os

from semantic_kernel import Kernel
from semantic_kernel.agents import AgentGroupChat, ChatCompletionAgent
from semantic_kernel.agents.strategies import (
    KernelFunctionSelectionStrategy,
    KernelFunctionTerminationStrategy,
)
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion,AzureChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistoryTruncationReducer
from semantic_kernel.functions import KernelFunctionFromPrompt, kernel_function
from semantic_kernel.functions.kernel_arguments import KernelArguments
from semantic_kernel.connectors.ai import FunctionChoiceBehavior



# Define agent names
REVIEWER_NAME = "Reviewer"
WRITER_NAME = "Writer"
SAVER_NAME = "Saver"

class FileSavePlugin:
    """ A Plugin used for saving files."""
# Function to save content to a file
@kernel_function(description="saves file to disk", name="save_to_file")
async def save_to_file(content: str):
    file_path = "output.txt"
    with open(file_path, "w", encoding="utf-8") as file:
        file.write(content)
    return f"Content saved to {file_path}"


def create_kernel() -> Kernel:
    """Creates a Kernel instance with an Azure OpenAI ChatCompletion service."""
    kernel = Kernel()
    kernel.add_service(service=AzureChatCompletion())

    return kernel


async def main():
    # Create a single kernel instance for all agents.
    kernel = create_kernel()

      # Get the AI Service settings
    settings = kernel.get_prompt_execution_settings_from_service_id("default")

        # Configure the function choice behavior to auto invoke kernel functions
    settings.function_choice_behavior = FunctionChoiceBehavior.Auto()

        # Add the Plugin to the Kernel
    kernel.add_plugin(FileSavePlugin(), plugin_name="FileSavePlugin")

    # Create ChatCompletionAgents using the same kernel.
    agent_reviewer = ChatCompletionAgent(
        kernel=kernel,
        name=REVIEWER_NAME,
        instructions="""
Your responsibility is to review and identify how to improve user-provided content.
If the user has provided input or direction for content already provided, specify how to address this input.
Never directly perform the correction or provide an example.
Once the content has been updated in a subsequent response, review it again until it is satisfactory.

RULES:
- Only identify suggestions that are specific and actionable.
- Verify previous suggestions have been addressed.
- Never repeat previous suggestions.
""",
    )

    agent_writer = ChatCompletionAgent(
        kernel=kernel,
        name=WRITER_NAME,
        instructions="""
Your sole responsibility is to rewrite content according to review suggestions.
- Always apply all review directions.
- Always revise the content in its entirety without explanation.
- Never address the user.
""",
    )

    # New Agent: Saver
    agent_saver = ChatCompletionAgent(
         kernel=kernel,
        name=SAVER_NAME,
        arguments=KernelArguments(settings=settings),
        instructions=f"""
Your responsibility is to save the final reviewed content.
- Always take the last content generated by {WRITER_NAME}.
- Call the function `save_to_file` with the content.
- Confirm once the content is saved.
""",
    )

    # Define a selection function to determine which agent should take the next turn.
    selection_function = KernelFunctionFromPrompt(
        function_name="selection",
        prompt=f"""
Examine the provided RESPONSE and choose the next participant.
State only the name of the chosen participant without explanation.
Never choose the participant named in the RESPONSE.

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

Rules:
- If RESPONSE is user input, it is {REVIEWER_NAME}'s turn.
- If RESPONSE is by {REVIEWER_NAME}, it is {WRITER_NAME}'s turn.
- If RESPONSE is by {WRITER_NAME}, it is<br/>
**Q&A: Creating Agent Group Chat Feature in Semantic Kernel**
===========================================================

**Q: What is Agent Group Chat in Semantic Kernel?**
----------------------------------------------

A: Agent Group Chat is a feature in Semantic Kernel that allows multiple agents to interact with each other in a conversation. Each agent has a specific role and responsibility, and they work together to achieve a common goal.

**Q: What are the challenges of implementing Agent Group Chat in Semantic Kernel?**
--------------------------------------------------------------------------------

A: Implementing Agent Group Chat in Semantic Kernel can be challenging due to the complexity of agent interactions, agent roles and responsibilities, and termination and selection strategies.

**Q: How do I define agent roles and responsibilities in Semantic Kernel?**
-------------------------------------------------------------------------

A: To define agent roles and responsibilities in Semantic Kernel, you need to create instances of the `ChatCompletionAgent` class for each agent. Each agent instance should have a unique name and instructions that define their role and responsibility in the conversation.

**Q: How do I create an instance of the `AgentGroupChat` class in Semantic Kernel?**
--------------------------------------------------------------------------------

A: To create an instance of the `AgentGroupChat` class in Semantic Kernel, you need to pass the following arguments:

*   `agents`: A list of `ChatCompletionAgent` instances that will participate in the conversation.
*   `selection_strategy`: An instance of the `KernelFunctionSelectionStrategy` class that defines how the next agent will be selected.
*   `termination_strategy`: An instance of the `KernelFunctionTerminationStrategy` class that defines how the conversation will be terminated.

**Q: How do I define a selection strategy in Semantic Kernel?**
---------------------------------------------------------

A: To define a selection strategy in Semantic Kernel, you need to create an instance of the `KernelFunctionSelectionStrategy` class. This class takes the following arguments:

*   `initial_agent`: The initial agent that will start the conversation.
*   `function`: A kernel function that will determine which agent should take the next turn.
*   `kernel`: The kernel instance that will be used to execute the kernel function.
*   `result_parser`: A function that will parse the result of the kernel function and determine which agent should take the next turn.
*   `history_variable_name`: The name of the variable that will store the conversation history.
*   `history_reducer`: An instance of the `ChatHistoryTruncationReducer` class that will reduce the conversation history.

**Q: How do I define a termination strategy in Semantic Kernel?**
---------------------------------------------------------

A: To define a termination strategy in Semantic Kernel, you need to create an instance of the `KernelFunctionTerminationStrategy` class. This class takes the following arguments:

*   `agents`: A list of agents that will participate in the conversation.
*   `function`: A kernel function that will determine when the conversation is complete.
*   `kernel`: The kernel instance that will be used to execute the kernel function.
*   `result_parser`: A function that will parse the result of the kernel function and determine when the conversation is complete.
*   `history_variable_name`: The name of the variable that will store the conversation history.
*   `maximum_iterations`: The maximum number of iterations that the conversation will be allowed to run.

**Q: How do I run the agent group chat in Semantic Kernel?**
---------------------------------------------------------

A: To run the agent group chat in Semantic Kernel, you need to call the `invoke` method on the `AgentGroupChat` instance. This method will start the conversation and execute the kernel functions defined in the selection and termination strategies.

**Q: What are some best practices for implementing agent group chat in Semantic Kernel?**
--------------------------------------------------------------------------------------

A: Some best practices for implementing agent group chat in Semantic Kernel include:

*   Defining clear roles and responsibilities for each agent.
*   Using kernel functions to determine which agent should take the next turn and when the conversation is complete.
*   Using a conversation history variable to store the conversation history.
*   Reducing the conversation history using a `ChatHistoryTruncationReducer` instance.
*   Testing the agent group chat thoroughly to ensure that it works as expected.