GroupChatManager

``autogen.GroupChatManager #

GroupChatManager(groupchat, name='chat_manager', max_consecutive_auto_reply=maxsize, human_input_mode='NEVER', system_message='Group chat manager.', silent=False, **kwargs)

Bases: ConversableAgent

(In preview) A chat manager agent that can manage a group chat of multiple agents.

Source code in autogen/agentchat/groupchat.py

``nameproperty#

name

Get the name of the agent.

description`propertywritable`#

description

Get the description of the agent.

``system_messageproperty#

system_message

Return the system message.

DEFAULT\_CONFIG`class-attributeinstance-attribute`#

DEFAULT_CONFIG = False

MAX\_CONSECUTIVE\_AUTO\_REPLY`class-attributeinstance-attribute`#

MAX_CONSECUTIVE_AUTO_REPLY = 100

DEFAULT\_SUMMARY\_PROMPT`class-attributeinstance-attribute`#

DEFAULT_SUMMARY_PROMPT = 'Summarize the takeaway from the conversation. Do not add any introductory phrases.'

DEFAULT\_SUMMARY\_METHOD`class-attributeinstance-attribute`#

DEFAULT_SUMMARY_METHOD = 'last_msg'

``llm_configinstance-attribute#

llm_config = _validate_llm_config(llm_config)

``handoffsinstance-attribute#

handoffs = handoffs if handoffs is not None else Handoffs()

``input_guardrailsinstance-attribute#

input_guardrails = []

``output_guardrailsinstance-attribute#

output_guardrails = []

``silentinstance-attribute#

silent = silent

``run_executorinstance-attribute#

run_executor = None

``clientinstance-attribute#

client = _create_client(llm_config)

``client_cacheinstance-attribute#

client_cache = None

``human_input_modeinstance-attribute#

human_input_mode = human_input_mode

``reply_at_receiveinstance-attribute#

reply_at_receive = defaultdict(bool)

``context_variablesinstance-attribute#

context_variables = context_variables if context_variables is not None else ContextVariables()

``hook_listsinstance-attribute#

hook_lists = {'process_last_received_message': [], 'process_all_messages_before_reply': [], 'process_message_before_send': [], 'update_agent_state': [], 'safeguard_tool_inputs': [], 'safeguard_tool_outputs': [], 'safeguard_llm_inputs': [], 'safeguard_llm_outputs': [], 'safeguard_human_inputs': []}

``code_executorproperty#

code_executor

The code executor used by this agent. Returns None if code execution is disabled.

``chat_messagesproperty#

chat_messages

A dictionary of conversations from agent to list of messages.

``use_dockerproperty#

use_docker

Bool value of whether to use docker to execute the code, or str value of the docker image name to use, or None when code execution is disabled.

``toolsproperty#

tools

Get the agent's tools (registered for LLM)

Note this is a copy of the tools list, use add_tool and remove_tool to modify the tools list.

``function_mapproperty#

function_map

Return the function map.

``groupchatproperty#

groupchat

Returns the group chat managed by the group chat manager.

``last_speakerproperty#

last_speaker

Return the agent who sent the last message to group chat manager.

In a group chat, an agent will always send a message to the group chat manager, and the group chat manager will send the message to all other agents in the group chat. So, when an agent receives a message, it will always be from the group chat manager. With this property, the agent receiving the message can know who actually sent the message.

Example:

from autogen import ConversableAgent
from autogen import GroupChat, GroupChatManager

def print_messages(recipient, messages, sender, config):
    # Print the message immediately
    print(f"Sender: {sender.name} | Recipient: {recipient.name} | Message: {messages[-1].get('content')}")
    print(f"Real Sender: {sender.last_speaker.name}")
    assert sender.last_speaker.name in messages[-1].get("content")
    return False, None  # Required to ensure the agent communication flow continues

agent_a = ConversableAgent("agent A", default_auto_reply="I'm agent A.")
agent_b = ConversableAgent("agent B", default_auto_reply="I'm agent B.")
agent_c = ConversableAgent("agent C", default_auto_reply="I'm agent C.")
for agent in [agent_a, agent_b, agent_c]:
    agent.register_reply([ConversableAgent, None], reply_func=print_messages, config=None)
group_chat = GroupChat(
    [agent_a, agent_b, agent_c],
    messages=[],
    max_round=6,
    speaker_selection_method="random",
    allow_repeat_speaker=True,
)
chat_manager = GroupChatManager(group_chat)
groupchat_result = agent_a.initiate_chat(chat_manager, message="Hi, there, I'm agent A.")

``send #

send(message, recipient, request_reply=None, silent=False)

Send a message to another agent.

{
    "content": lambda context: context["use_tool_msg"],
    "context": {"use_tool_msg": "Use tool X if they are relevant."},
}

Next time, one agent can send a message B with a different "use_tool_msg". Then the content of message A will be refreshed to the new "use_tool_msg". So effectively, this provides a way for an agent to send a "link" and modify the content of the "link" later. recipient (Agent): the recipient of the message. request_reply (bool or None): whether to request a reply from the recipient. silent (bool or None): (Experimental) whether to print the message sent.

Source code in autogen/agentchat/conversable_agent.py

``a_sendasync#

a_send(message, recipient, request_reply=None, silent=False)

(async) Send a message to another agent.

{
    "content": lambda context: context["use_tool_msg"],
    "context": {"use_tool_msg": "Use tool X if they are relevant."},
}

Source code in autogen/agentchat/conversable_agent.py

``receive #

receive(message, sender, request_reply=None, silent=False)

Receive a message from another agent.

Once a message is received, this function sends a reply to the sender or stop. The reply can be generated automatically or entered manually by a human.

Source code in autogen/agentchat/conversable_agent.py

``a_receiveasync#

a_receive(message, sender, request_reply=None, silent=False)

(async) Receive a message from another agent.

Once a message is received, this function sends a reply to the sender or stop. The reply can be generated automatically or entered manually by a human.

Source code in autogen/agentchat/conversable_agent.py

``generate_reply #

generate_reply(messages=None, sender=None, exclude=())

Reply based on the conversation history and the sender.

Either messages or sender must be provided. Register a reply_func with None as one trigger for it to be activated when messages is non-empty and sender is None. Use registered auto reply functions to generate replies. By default, the following functions are checked in order: 1. check_termination_and_human_reply 2. generate_function_call_reply (deprecated in favor of tool_calls) 3. generate_tool_calls_reply 4. generate_code_execution_reply 5. generate_oai_reply Every function returns a tuple (final, reply). When a function returns final=False, the next function will be checked. So by default, termination and human reply will be checked first. If not terminating and human reply is skipped, execute function or code and return the result. AI replies are generated only when no code execution is performed.

Source code in autogen/agentchat/conversable_agent.py

``a_generate_replyasync#

a_generate_reply(messages=None, sender=None, exclude=())

(async) Reply based on the conversation history and the sender.

Either messages or sender must be provided. Register a reply_func with None as one trigger for it to be activated when messages is non-empty and sender is None. Use registered auto reply functions to generate replies. By default, the following functions are checked in order: 1. check_termination_and_human_reply 2. generate_function_call_reply 3. generate_tool_calls_reply 4. generate_code_execution_reply 5. generate_oai_reply Every function returns a tuple (final, reply). When a function returns final=False, the next function will be checked. So by default, termination and human reply will be checked first. If not terminating and human reply is skipped, execute function or code and return the result. AI replies are generated only when no code execution is performed.

Source code in autogen/agentchat/conversable_agent.py

``set_ui_tools #

set_ui_tools(tools)

Set the UI tools for the agent.

Source code in autogen/agentchat/conversable_agent.py

``unset_ui_tools #

unset_ui_tools(tools)

Unset the UI tools for the agent.

Source code in autogen/agentchat/conversable_agent.py

``update_system_message #

update_system_message(system_message)

Update the system message.

Source code in autogen/agentchat/conversable_agent.py

``register_reply #

register_reply(trigger, reply_func, position=0, config=None, reset_config=None, *, ignore_async_in_sync_chat=False, remove_other_reply_funcs=False)

Register a reply function.

The reply function will be called when the trigger matches the sender. The function registered later will be checked earlier by default. To change the order, set the position to a positive integer.

Both sync and async reply functions can be registered. The sync reply function will be triggered from both sync and async chats. However, an async reply function will only be triggered from async chats (initiated with ConversableAgent.a_initiate_chat). If an async reply function is registered and a chat is initialized with a sync function, ignore_async_in_sync_chat determines the behaviour as follows: if ignore_async_in_sync_chat is set to False (default value), an exception will be raised, and if ignore_async_in_sync_chat is set to True, the reply function will be ignored.

Source code in autogen/agentchat/conversable_agent.py

``replace_reply_func #

replace_reply_func(old_reply_func, new_reply_func)

Replace a registered reply function with a new one.

Source code in autogen/agentchat/conversable_agent.py

``register_nested_chats #

register_nested_chats(chat_queue, trigger, reply_func_from_nested_chats='summary_from_nested_chats', position=2, use_async=None, **kwargs)

Register a nested chat reply function.

Source code in autogen/agentchat/conversable_agent.py

``update_max_consecutive_auto_reply #

update_max_consecutive_auto_reply(value, sender=None)

Update the maximum number of consecutive auto replies.

Source code in autogen/agentchat/conversable_agent.py

``max_consecutive_auto_reply #

max_consecutive_auto_reply(sender=None)

The maximum number of consecutive auto replies.

Source code in autogen/agentchat/conversable_agent.py

``last_message #

last_message(agent=None)

The last message exchanged with the agent.

Source code in autogen/agentchat/conversable_agent.py

``initiate_chat #

initiate_chat(recipient, clear_history=True, silent=False, cache=None, max_turns=None, summary_method=DEFAULT_SUMMARY_METHOD, summary_args={}, message=None, **kwargs)

Initiate a chat with the recipient agent.

Reset the consecutive auto reply counter. If clear_history is True, the chat history with the recipient agent will be cleared.

Source code in autogen/agentchat/conversable_agent.py

``run #

run(recipient=None, clear_history=True, silent=False, cache=None, max_turns=None, summary_method=DEFAULT_SUMMARY_METHOD, summary_args={}, message=None, executor_kwargs=None, tools=None, user_input=False, msg_to='agent', **kwargs)

Source code in autogen/agentchat/conversable_agent.py

``a_initiate_chatasync#

a_initiate_chat(recipient, clear_history=True, silent=False, cache=None, max_turns=None, summary_method=DEFAULT_SUMMARY_METHOD, summary_args={}, message=None, **kwargs)

(async) Initiate a chat with the recipient agent.

Reset the consecutive auto reply counter. If clear_history is True, the chat history with the recipient agent will be cleared. a_generate_init_message is called to generate the initial message for the agent.

Args: Please refer to initiate_chat.

Source code in autogen/agentchat/conversable_agent.py

``a_runasync#

a_run(recipient=None, clear_history=True, silent=False, cache=None, max_turns=None, summary_method=DEFAULT_SUMMARY_METHOD, summary_args={}, message=None, executor_kwargs=None, tools=None, user_input=False, msg_to='agent', **kwargs)

Source code in autogen/agentchat/conversable_agent.py

``initiate_chats #

initiate_chats(chat_queue)

(Experimental) Initiate chats with multiple agents.

Returns: a list of ChatResult objects corresponding to the finished chats in the chat_queue.

Source code in autogen/agentchat/conversable_agent.py

``sequential_run #

sequential_run(chat_queue)

(Experimental) Initiate chats with multiple agents sequentially.

Returns: a list of ChatResult objects corresponding to the finished chats in the chat_queue.

Source code in autogen/agentchat/conversable_agent.py

``a_initiate_chatsasync#

a_initiate_chats(chat_queue)

Source code in autogen/agentchat/conversable_agent.py

``a_sequential_runasync#

a_sequential_run(chat_queue)

(Experimental) Initiate chats with multiple agents sequentially.

Returns: a list of ChatResult objects corresponding to the finished chats in the chat_queue.

Source code in autogen/agentchat/conversable_agent.py

``get_chat_results #

get_chat_results(chat_index=None)

A summary from the finished chats of particular agents.

Source code in autogen/agentchat/conversable_agent.py

``reset #

reset()

Reset the agent.

Source code in autogen/agentchat/conversable_agent.py

``stop_reply_at_receive #

stop_reply_at_receive(sender=None)

Reset the reply_at_receive of the sender.

Source code in autogen/agentchat/conversable_agent.py

``reset_consecutive_auto_reply_counter #

reset_consecutive_auto_reply_counter(sender=None)

Reset the consecutive_auto_reply_counter of the sender.

Source code in autogen/agentchat/conversable_agent.py

``clear_history #

clear_history(recipient=None, nr_messages_to_preserve=None)

Clear the chat history of the agent.

Source code in autogen/agentchat/conversable_agent.py

``generate_oai_reply #

generate_oai_reply(messages=None, sender=None, config=None, **kwargs)

Generate a reply using autogen.oai.

Source code in autogen/agentchat/conversable_agent.py

``a_generate_oai_replyasync#

a_generate_oai_reply(messages=None, sender=None, config=None, **kwargs)

Generate a reply using autogen.oai asynchronously.

Source code in autogen/agentchat/conversable_agent.py

``generate_code_execution_reply #

generate_code_execution_reply(messages=None, sender=None, config=None)

Generate a reply using code execution.

Source code in autogen/agentchat/conversable_agent.py

``generate_function_call_reply #

generate_function_call_reply(messages=None, sender=None, config=None)

Generate a reply using function call.

"function_call" replaced by "tool_calls" as of OpenAI API v1.1.0 See https://platform.openai.com/docs/api-reference/chat/create#chat-create-functions

Source code in autogen/agentchat/conversable_agent.py

``a_generate_function_call_replyasync#

a_generate_function_call_reply(messages=None, sender=None, config=None)

Generate a reply using async function call.

Source code in autogen/agentchat/conversable_agent.py

``generate_tool_calls_reply #

generate_tool_calls_reply(messages=None, sender=None, config=None)

Generate a reply using tool call.

Source code in autogen/agentchat/conversable_agent.py

``a_generate_tool_calls_replyasync#

a_generate_tool_calls_reply(messages=None, sender=None, config=None)

Generate a reply using async function call.

Source code in autogen/agentchat/conversable_agent.py

``check_termination_and_human_reply #

check_termination_and_human_reply(messages=None, sender=None, config=None, iostream=None)

Check if the conversation should be terminated, and if human reply is provided.

This method checks for conditions that require the conversation to be terminated, such as reaching a maximum number of consecutive auto-replies or encountering a termination message. Additionally, it prompts for and processes human input based on the configured human input mode, which can be 'ALWAYS', 'NEVER', or 'TERMINATE'. The method also manages the consecutive auto-reply counter for the conversation and prints relevant messages based on the human input received.

Source code in autogen/agentchat/conversable_agent.py

``a_check_termination_and_human_replyasync#

a_check_termination_and_human_reply(messages=None, sender=None, config=None, iostream=None)

(async) Check if the conversation should be terminated, and if human reply is provided.

Returns: Tuple[bool, Union[str, Dict, None]]: A tuple containing a boolean indicating if the conversation should be terminated, and a human reply which can be a string, a dictionary, or None.

Source code in autogen/agentchat/conversable_agent.py

``get_human_input #

get_human_input(prompt, *, iostream=None)

Get human input.

Override this method to customize the way to get human input.

Returns: str: human input.

Source code in autogen/agentchat/conversable_agent.py

``a_get_human_inputasync#

a_get_human_input(prompt, *, iostream=None)

(Async) Get human input.

Override this method to customize the way to get human input.

Returns: str: human input.

Source code in autogen/agentchat/conversable_agent.py

``run_code #

run_code(code, **kwargs)

Run the code and return the result.

Override this function to modify the way to run the code.

Source code in autogen/agentchat/conversable_agent.py

``execute_code_blocks #

execute_code_blocks(code_blocks)

Execute the code blocks and return the result.

Source code in autogen/agentchat/conversable_agent.py

``execute_function #

execute_function(func_call, call_id=None, verbose=False)

Execute a function call and return the result.

Override this function to modify the way to execute function and tool calls.

"function_call" deprecated as of OpenAI API v1.1.0 See https://platform.openai.com/docs/api-reference/chat/create#chat-create-function\_call

Source code in autogen/agentchat/conversable_agent.py

``a_execute_functionasync#

a_execute_function(func_call, call_id=None, verbose=False)

Execute an async function call and return the result.

Override this function to modify the way async functions and tools are executed.

Source code in autogen/agentchat/conversable_agent.py

``generate_init_message #

generate_init_message(message, **kwargs)

Generate the initial message for the agent. If message is None, input() will be called to get the initial message.

Source code in autogen/agentchat/conversable_agent.py

``a_generate_init_messageasync#

a_generate_init_message(message, **kwargs)

Generate the initial message for the agent. If message is None, input() will be called to get the initial message.

Source code in autogen/agentchat/conversable_agent.py

``remove_tool_for_llm #

remove_tool_for_llm(tool)

Remove a tool (register for LLM tool)

Source code in autogen/agentchat/conversable_agent.py

``register_function #

register_function(function_map, silent_override=False)

Register functions to the agent.

Source code in autogen/agentchat/conversable_agent.py

``update_function_signature #

update_function_signature(func_sig, is_remove=False, silent_override=False)

Update a function_signature in the LLM configuration for function_call.

Deprecated as of OpenAI API v1.1.0 See https://platform.openai.com/docs/api-reference/chat/create#chat-create-function\_call

Source code in autogen/agentchat/conversable_agent.py

``update_tool_signature #

update_tool_signature(tool_sig, is_remove, silent_override=False)

Update a tool_signature in the LLM configuration for tool_call.

Source code in autogen/agentchat/conversable_agent.py

``can_execute_function #

can_execute_function(name)

Whether the agent can execute the function.

Source code in autogen/agentchat/conversable_agent.py

``register_for_llm #

register_for_llm(*, name=None, description=None, api_style='tool', silent_override=False)

Decorator factory for registering a function to be used by an agent.

It's return value is used to decorate a function to be registered to the agent. The function uses type hints to specify the arguments and return type. The function name is used as the default name for the function, but a custom name can be provided. The function description is used to describe the function in the agent's configuration.

Examples:

@user_proxy.register_for_execution()
@agent2.register_for_llm()
@agent1.register_for_llm(description="This is a very useful function")
def my_function(a: Annotated[str, "description of a parameter"] = "a", b: int, c=3.14) -> str:
     return a + str(b * c)

For Azure OpenAI versions prior to 2023-12-01-preview, set api_style to "function" if "tool" doesn't work:

@agent2.register_for_llm(api_style="function")
def my_function(a: Annotated[str, "description of a parameter"] = "a", b: int, c=3.14) -> str:
     return a + str(b * c)

Source code in autogen/agentchat/conversable_agent.py

``register_for_execution #

register_for_execution(name=None, description=None, *, serialize=True, silent_override=False)

Decorator factory for registering a function to be executed by an agent.

It's return value is used to decorate a function to be registered to the agent.

Examples:

@user_proxy.register_for_execution()
@agent2.register_for_llm()
@agent1.register_for_llm(description="This is a very useful function")
def my_function(a: Annotated[str, "description of a parameter"] = "a", b: int, c=3.14):
     return a + str(b * c)

Source code in autogen/agentchat/conversable_agent.py

``register_model_client #

register_model_client(model_client_cls, **kwargs)

Register a model client.

Source code in autogen/agentchat/conversable_agent.py

``register_hook #

register_hook(hookable_method, hook)

Registers a hook to be called by a hookable method, in order to add a capability to the agent. Registered hooks are kept in lists (one per hookable method), and are called in their order of registration.

Source code in autogen/agentchat/conversable_agent.py

``update_agent_state_before_reply #

update_agent_state_before_reply(messages)

Calls any registered capability hooks to update the agent's state. Primarily used to update context variables. Will, potentially, modify the messages.

Source code in autogen/agentchat/conversable_agent.py

``process_all_messages_before_reply #

process_all_messages_before_reply(messages)

Calls any registered capability hooks to process all messages, potentially modifying the messages.

Source code in autogen/agentchat/conversable_agent.py

``process_last_received_message #

process_last_received_message(messages)

Calls any registered capability hooks to use and potentially modify the text of the last message, as long as the last message is not a function call or exit command.

Source code in autogen/agentchat/conversable_agent.py

``print_usage_summary #

print_usage_summary(mode=['actual', 'total'])

Print the usage summary.

Source code in autogen/agentchat/conversable_agent.py

``get_actual_usage #

get_actual_usage()

Get the actual usage summary.

Source code in autogen/agentchat/conversable_agent.py

``get_total_usage #

get_total_usage()

Get the total usage summary.

Source code in autogen/agentchat/conversable_agent.py

``register_handoff #

register_handoff(condition)

Register a single handoff condition (OnContextCondition or OnCondition).

Source code in autogen/agentchat/conversable_agent.py

``register_handoffs #

register_handoffs(conditions)

Register multiple handoff conditions (OnContextCondition or OnCondition).

Source code in autogen/agentchat/conversable_agent.py

``register_input_guardrail #

register_input_guardrail(guardrail)

Register a guardrail to be used for input validation.

Source code in autogen/agentchat/conversable_agent.py

``register_input_guardrails #

register_input_guardrails(guardrails)

Register multiple guardrails to be used for input validation.

Source code in autogen/agentchat/conversable_agent.py

``register_output_guardrail #

register_output_guardrail(guardrail)

Register a guardrail to be used for output validation.

Source code in autogen/agentchat/conversable_agent.py

``register_output_guardrails #

register_output_guardrails(guardrails)

Register multiple guardrails to be used for output validation.

Source code in autogen/agentchat/conversable_agent.py

``run_input_guardrails #

run_input_guardrails(messages=None)

Run input guardrails for an agent before the reply is generated.

Source code in autogen/agentchat/conversable_agent.py

``run_output_guardrails #

run_output_guardrails(reply)

Run output guardrails for an agent after the reply is generated.

Source code in autogen/agentchat/conversable_agent.py

``chat_messages_for_summary #

chat_messages_for_summary(agent)

The list of messages in the group chat as a conversation to summarize. The agent is ignored.

Source code in autogen/agentchat/groupchat.py

``run_chat #

run_chat(messages=None, sender=None, config=None)

Run a group chat.

Source code in autogen/agentchat/groupchat.py

``a_run_chatasync#

a_run_chat(messages=None, sender=None, config=None)

Run a group chat asynchronously.

Source code in autogen/agentchat/groupchat.py

``resume #

resume(messages, remove_termination_string=None, silent=False)

Resumes a group chat using the previous messages as a starting point. Requires the agents, group chat, and group chat manager to be established as per the original group chat.

Source code in autogen/agentchat/groupchat.py

``a_resumeasync#

a_resume(messages, remove_termination_string=None, silent=False)

Resumes a group chat using the previous messages as a starting point, asynchronously. Requires the agents, group chat, and group chat manager to be established as per the original group chat.

Source code in autogen/agentchat/groupchat.py

``messages_from_string #

messages_from_string(message_string)

Reads the saved state of messages in Json format for resume and returns as a messages list

Source code in autogen/agentchat/groupchat.py

``messages_to_string #

messages_to_string(messages)

Converts the provided messages into a Json string that can be used for resuming the chat. The state is made up of a list of messages

Source code in autogen/agentchat/groupchat.py

``clear_agents_history #

clear_agents_history(reply, groupchat)

Clears history of messages for all agents or a selected one. Can preserve a selected number of last messages.

This function is called when the user manually provides the "clear history" phrase in their reply.

When "clear history" is provided, the history of messages for all agents is cleared.

When "clear history <agent_name>" is provided, the history of messages for the selected agent is cleared.

When "clear history <nr_of_messages_to_preserve>" is provided, the history of messages for all agents is cleared

except for the last <nr_of_messages_to_preserve> messages.

When "clear history <agent_name>``<nr_of_messages_to_preserve>" is provided, the history of messages for the selected

agent is cleared except for the last <nr_of_messages_to_preserve> messages.

The phrase "clear history" and optional arguments are cut out from the reply before it is passed to the chat.

Args:

reply (dict): reply message dict to analyze.

groupchat (GroupChat): GroupChat object.

Source code in autogen/agentchat/groupchat.py

Back to top