diff --git a/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb b/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb new file mode 100644 index 00000000000..bf69277a233 --- /dev/null +++ b/notebook/agentchat_hierarchy_flow_using_select_speaker.ipynb @@ -0,0 +1,392 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "attachments": { + "e6173a72-fa95-49db-83c8-899608860952.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Auto Generated Agent Chat: Hierarchy flow using select_speaker\n", + "\n", + "AutoGen offers conversable agents powered by LLM, tool, or human, which can be used to perform tasks collectively via automated chat. This framework allows tool use and human participation through multi-agent conversation.\n", + "Please find documentation about this feature [here](https://microsoft.github.io/autogen/docs/Use-Cases/agent_chat).\n", + "\n", + "This notebook is about restricting information flow within agents. Suppose we have the following setup:\n", + "\n", + "![image.png](attachment:e6173a72-fa95-49db-83c8-899608860952.png)\n", + "\n", + "Constraints:\n", + "- Team leaders can talk amongst themselves\n", + "- A team can talk amongst themselves\n", + "\n", + "Benefits\n", + "- By limiting team members can talk to team members, we bring focus to the team.\n", + "- Information flow from Team A to Team B is made more efficient to let the X1s talk amongst themselves. It is more efficient as agent B2 do not have to see the discussion within Team A.\n", + "\n", + "\n", + "## Requirements\n", + "\n", + "AutoGen requires `Python>=3.8`. To run this notebook example, please install:\n", + "```bash\n", + "pip install pyautogen\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%%capture --no-stderr\n", + "# %pip install pyautogen~=0.1.0" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set your API Endpoint\n", + "\n", + "The [`config_list_from_json`](https://microsoft.github.io/autogen/docs/reference/oai/openai_utils#config_list_from_json) function loads a list of configurations from an environment variable or a json file." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.2.0b1\n" + ] + } + ], + "source": [ + "import autogen\n", + "\n", + "print(autogen.__version__)\n", + "\n", + "# The default config list in notebook.\n", + "config_list_gpt4 = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt4\", \"gpt-4-32k\", \"gpt-4-32k-0314\", \"gpt-4-32k-v0314\"],\n", + " },\n", + ")\n", + "\n", + "# Contributor's config - Please replace with your own, I have replaced mine with an Azure OpenAI endpoint.\n", + "config_list_gpt4 = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\"],\n", + " },\n", + " )" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It first looks for environment variable \"OAI_CONFIG_LIST\" which needs to be a valid json string. If that variable is not found, it then looks for a json file named \"OAI_CONFIG_LIST\". It filters the configs by models (you can filter by other keys as well). Only the gpt-4 models are kept in the list based on the filter condition.\n", + "\n", + "The config list looks like the following:\n", + "```python\n", + "config_list = [\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " },\n", + " {\n", + " 'model': 'gpt-4',\n", + " 'api_key': '',\n", + " 'base_url': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + " {\n", + " 'model': 'gpt-4-32k',\n", + " 'api_key': '',\n", + " 'base_url': '',\n", + " 'api_type': 'azure',\n", + " 'api_version': '2023-06-01-preview',\n", + " },\n", + "]\n", + "```\n", + "\n", + "If you open this notebook in colab, you can upload your files by clicking the file icon on the left panel and then choosing \"upload file\" icon.\n", + "\n", + "You can set the value of config_list in other ways you prefer, e.g., loading from a YAML file." + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extending GroupChat\n", + "\n", + "\n", + "Custom Speaker Selection Logic: The CustomGroupChat class allows us to define our own logic for selecting the next speaker in the group chat. The base GroupChat class has a default logic that may not be suitable for all scenarios.\n", + "\n", + "\n", + "Content-Driven Speaker Selection: This custom class lets us select the next speaker based on the content of the last message, like \"NEXT: A2\" or \"TERMINATE\". The base GroupChat class does not have this capability.\n", + "\n", + "Team-Based Logic: The custom class enables team-based logic for speaker selection. It allows the next speaker to be chosen from the same team as the last speaker or from a pool of team leaders, which is something the base GroupChat class does not offer.\n", + "\n", + "Previous Speaker Exclusion: The CustomGroupChat class includes logic to prevent the last speaker and the previous speaker from being selected again immediately, which adds more dynamism to the conversation.\n", + "\n", + "Flexibility: Extending the base GroupChat class allows us to preserve the existing functionalities and methods while adding new features specific to our needs. This makes the code more modular and easier to maintain.\n", + "\n", + "Special Cases Handling: The custom class can also handle special cases, like terminating the chat or transitioning to a 'User_proxy', directly within its select_speaker method.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "llm_config = {\"config_list\": config_list_gpt4, \"seed\": 42}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from autogen.agentchat.groupchat import GroupChat\n", + "from autogen.agentchat.agent import Agent\n", + "from autogen.agentchat.assistant_agent import AssistantAgent" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import random\n", + "from typing import List, Dict\n", + "\n", + "class CustomGroupChat(GroupChat):\n", + " def __init__(self, agents, messages, max_round=10):\n", + " super().__init__(agents, messages, max_round)\n", + " self.previous_speaker = None # Keep track of the previous speaker\n", + " \n", + " def select_speaker(self, last_speaker: Agent, selector: AssistantAgent):\n", + " # Check if last message suggests a next speaker or termination\n", + " last_message = self.messages[-1] if self.messages else None\n", + " if last_message:\n", + " if 'NEXT:' in last_message['content']:\n", + " suggested_next = last_message['content'].split('NEXT: ')[-1].strip()\n", + " print(f'Extracted suggested_next = {suggested_next}')\n", + " try:\n", + " return self.agent_by_name(suggested_next)\n", + " except ValueError:\n", + " pass # If agent name is not valid, continue with normal selection\n", + " elif 'TERMINATE' in last_message['content']:\n", + " try:\n", + " return self.agent_by_name('User_proxy')\n", + " except ValueError:\n", + " pass # If 'User_proxy' is not a valid name, continue with normal selection\n", + " \n", + " team_leader_names = [agent.name for agent in self.agents if agent.name.endswith('1')]\n", + "\n", + " if last_speaker.name in team_leader_names:\n", + " team_letter = last_speaker.name[0]\n", + " possible_next_speakers = [\n", + " agent for agent in self.agents if (agent.name.startswith(team_letter) or agent.name in team_leader_names) \n", + " and agent != last_speaker and agent != self.previous_speaker\n", + " ]\n", + " else:\n", + " team_letter = last_speaker.name[0]\n", + " possible_next_speakers = [\n", + " agent for agent in self.agents if agent.name.startswith(team_letter) \n", + " and agent != last_speaker and agent != self.previous_speaker\n", + " ]\n", + "\n", + " self.previous_speaker = last_speaker\n", + "\n", + " if possible_next_speakers:\n", + " next_speaker = random.choice(possible_next_speakers)\n", + " return next_speaker\n", + " else:\n", + " return None\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Termination message detection\n", + "def is_termination_msg(content) -> bool:\n", + " have_content = content.get(\"content\", None) is not None\n", + " if have_content and \"TERMINATE\" in content[\"content\"]:\n", + " return True\n", + " return False" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mB2\u001b[0m (to chat_manager):\n", + "\n", + "Find the product of x and y, the other agents know x and y.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mB1\u001b[0m (to chat_manager):\n", + "\n", + "NEXT: A1\n", + "Can you or any of your team members provide the values for x and y? B2 needs these values to complete a task.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Extracted suggested_next = A1\n", + "Can you or any of your team members provide the values for x and y? B2 needs these values to complete a task.\n", + "\u001b[33mA1\u001b[0m (to chat_manager):\n", + "\n", + "Sure B1, let me check with my team. \n", + "\n", + "NEXT: A2, A3\n", + "Could either of you provide the values for x and y? B2 needs these values to complete a task.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Extracted suggested_next = A2, A3\n", + "Could either of you provide the values for x and y? B2 needs these values to complete a task.\n", + "\u001b[33mA2\u001b[0m (to chat_manager):\n", + "\n", + "Sure, I hold the value for x. We know x is equal to 9. A3, could you please provide the value of y?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mA3\u001b[0m (to chat_manager):\n", + "\n", + "Sure, the value of y that I hold is 5.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mA1\u001b[0m (to chat_manager):\n", + "\n", + "NEXT: B1\n", + "The values we have for x and y are x=9, y=5. Could you pass this information to B2 to complete the task?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Extracted suggested_next = B1\n", + "The values we have for x and y are x=9, y=5. Could you pass this information to B2 to complete the task?\n", + "\u001b[33mB1\u001b[0m (to chat_manager):\n", + "\n", + "Absolutely, A1.\n", + "\n", + "NEXT: B2\n", + "The values for x and y are x=9, y=5. Could you please compute the product of x and y?\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Extracted suggested_next = B2\n", + "The values for x and y are x=9, y=5. Could you please compute the product of x and y?\n", + "\u001b[33mB2\u001b[0m (to chat_manager):\n", + "\n", + "Sure, the product of x and y, where x=9 and y=5, is 45.\n", + "\n", + "TERMINATE.\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + } + ], + "source": [ + "# Initialization\n", + "agents_A = [\n", + " AssistantAgent(name='A1', \n", + " system_message=\"You are a team leader A1, your team consists of A2, A3. You can talk to the other team leader B1, whose team member is B2.\",\n", + " llm_config=llm_config),\n", + " AssistantAgent(name='A2', \n", + " system_message=\"You are team member A2, you know the secret value of x but not y, x = 9. Tell others x to cooperate.\",\n", + " llm_config=llm_config),\n", + " AssistantAgent(name='A3', \n", + " system_message=\"You are team member A3, You know the secret value of y but not x, y = 5. Tell others y to cooperate.\",\n", + " llm_config=llm_config)\n", + "]\n", + "\n", + "agents_B = [\n", + " AssistantAgent(name='B1', \n", + " system_message=\"You are a team leader B1, your team consists of B2. You can talk to the other team leader A1, whose team member is A2, A3. Use NEXT: A1 to suggest talking to A1.\",\n", + " llm_config=llm_config),\n", + " AssistantAgent(name='B2', \n", + " system_message=\"You are team member B2. Your task is to find out the value of x and y and compute the product. Once you have the answer, say out the answer and append a new line with TERMINATE.\",\n", + " llm_config=llm_config)\n", + "]\n", + "\n", + "# Terminates the conversation when TERMINATE is detected.\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"User_proxy\",\n", + " system_message=\"Terminator admin.\",\n", + " code_execution_config=False,\n", + " is_termination_msg=is_termination_msg,\n", + " human_input_mode=\"NEVER\")\n", + "\n", + "list_of_agents = agents_A + agents_B\n", + "list_of_agents.append(user_proxy)\n", + "\n", + "# Create CustomGroupChat\n", + "group_chat = CustomGroupChat(\n", + " agents=list_of_agents, # Include all agents\n", + " messages=['Everyone cooperate and help agent B2 in his task. Team A has A1, A2, A3. Team B has B1, B2. Only members of the same team can talk to one another. Only team leaders (names ending with 1) can talk amongst themselves. You must use \"NEXT: B1\" to suggest talking to B1 for example; You can suggest only one person, you cannot suggest yourself or the previous speaker; You can also dont suggest anyone.'],\n", + " max_round=30\n", + ")\n", + "\n", + "\n", + "# Create the manager\n", + "llm_config = {\"config_list\": config_list_gpt4, \"seed\": 42, \"use_cache\":False} # use_cache is False because we want to observe if there is any communication pattern difference if we reran the group chat.\n", + "manager = autogen.GroupChatManager(groupchat=group_chat, llm_config=llm_config)\n", + "\n", + "\n", + "# Initiates the chat with B2\n", + "agents_B[1].initiate_chat(manager, message=\"Find the product of x and y, the other agents know x and y.\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/test/test_notebook.py b/test/test_notebook.py index 0c0adf1cb33..014724c1db0 100644 --- a/test/test_notebook.py +++ b/test/test_notebook.py @@ -1,92 +1,100 @@ -import sys -import os -import pytest - -try: - import openai - - skip = False -except ImportError: - skip = True - - -here = os.path.abspath(os.path.dirname(__file__)) - - -def run_notebook(input_nb, output_nb="executed_openai_notebook.ipynb", save=False): - import nbformat - from nbconvert.preprocessors import ExecutePreprocessor - from nbconvert.preprocessors import CellExecutionError - - try: - nb_loc = os.path.join(here, os.pardir, "notebook") - file_path = os.path.join(nb_loc, input_nb) - with open(file_path) as nb_file: - nb = nbformat.read(nb_file, as_version=4) - preprocessor = ExecutePreprocessor(timeout=4800, kernel_name="python3") - preprocessor.preprocess(nb, {"metadata": {"path": nb_loc}}) - - output_file_name = "executed_openai_notebook_output.txt" - output_file = os.path.join(here, output_file_name) - with open(output_file, "a") as nb_output_file: - for cell in nb.cells: - if cell.cell_type == "code" and "outputs" in cell: - for output in cell.outputs: - if "text" in output: - nb_output_file.write(output["text"].strip() + "\n") - elif "data" in output and "text/plain" in output["data"]: - nb_output_file.write(output["data"]["text/plain"].strip() + "\n") - except CellExecutionError: - raise - finally: - if save: - with open(os.path.join(here, output_nb), "w", encoding="utf-8") as nb_executed_file: - nbformat.write(nb, nb_executed_file) - - -@pytest.mark.skipif( - skip or not sys.version.startswith("3.11"), - reason="do not run if openai is not installed or py!=3.11", -) -def test_agentchat_auto_feedback_from_code(save=False): - run_notebook("agentchat_auto_feedback_from_code_execution.ipynb", save=save) - - -@pytest.mark.skipif( - skip or not sys.version.startswith("3.10"), - reason="do not run if openai is not installed or py!=3.10", -) -def _test_oai_completion(save=False): - run_notebook("oai_completion.ipynb", save=save) - - -@pytest.mark.skipif( - skip or not sys.version.startswith("3.10"), - reason="do not run if openai is not installed or py!=3.10", -) -def test_agentchat_function_call(save=False): - run_notebook("agentchat_function_call.ipynb", save=save) - - -@pytest.mark.skipif( - skip or not sys.version.startswith("3.10"), - reason="do not run if openai is not installed or py!=3.10", -) -def _test_agentchat_MathChat(save=False): - run_notebook("agentchat_MathChat.ipynb", save=save) - - -@pytest.mark.skipif( - skip or not sys.version.startswith("3.11"), - reason="do not run if openai is not installed or py!=3.11", -) -def _test_oai_chatgpt_gpt4(save=False): - run_notebook("oai_chatgpt_gpt4.ipynb", save=save) - - -if __name__ == "__main__": - test_agentchat_auto_feedback_from_code(save=True) - # test_oai_chatgpt_gpt4(save=True) - # test_oai_completion(save=True) - # test_agentchat_MathChat(save=True) - # test_agentchat_function_call(save=True) +import sys +import os +import pytest + +try: + import openai + + skip = False +except ImportError: + skip = True + + +here = os.path.abspath(os.path.dirname(__file__)) + + +def run_notebook(input_nb, output_nb="executed_openai_notebook.ipynb", save=False): + import nbformat + from nbconvert.preprocessors import ExecutePreprocessor + from nbconvert.preprocessors import CellExecutionError + + try: + nb_loc = os.path.join(here, os.pardir, "notebook") + file_path = os.path.join(nb_loc, input_nb) + with open(file_path) as nb_file: + nb = nbformat.read(nb_file, as_version=4) + preprocessor = ExecutePreprocessor(timeout=4800, kernel_name="python3") + preprocessor.preprocess(nb, {"metadata": {"path": nb_loc}}) + + output_file_name = "executed_openai_notebook_output.txt" + output_file = os.path.join(here, output_file_name) + with open(output_file, "a") as nb_output_file: + for cell in nb.cells: + if cell.cell_type == "code" and "outputs" in cell: + for output in cell.outputs: + if "text" in output: + nb_output_file.write(output["text"].strip() + "\n") + elif "data" in output and "text/plain" in output["data"]: + nb_output_file.write(output["data"]["text/plain"].strip() + "\n") + except CellExecutionError: + raise + finally: + if save: + with open(os.path.join(here, output_nb), "w", encoding="utf-8") as nb_executed_file: + nbformat.write(nb, nb_executed_file) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.11"), + reason="do not run if openai is not installed or py!=3.11", +) +def test_agentchat_auto_feedback_from_code(save=False): + run_notebook("agentchat_auto_feedback_from_code_execution.ipynb", save=save) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.10"), + reason="do not run if openai is not installed or py!=3.10", +) +def _test_oai_completion(save=False): + run_notebook("oai_completion.ipynb", save=save) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.10"), + reason="do not run if openai is not installed or py!=3.10", +) +def test_agentchat_function_call(save=False): + run_notebook("agentchat_function_call.ipynb", save=save) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.10"), + reason="do not run if openai is not installed or py!=3.10", +) +def _test_agentchat_MathChat(save=False): + run_notebook("agentchat_MathChat.ipynb", save=save) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.11"), + reason="do not run if openai is not installed or py!=3.11", +) +def _test_oai_chatgpt_gpt4(save=False): + run_notebook("oai_chatgpt_gpt4.ipynb", save=save) + + +@pytest.mark.skipif( + skip or not sys.version.startswith("3.10"), + reason="do not run if openai is not installed or py!=3.10", +) +def test_hierarchy_flow_using_select_speaker(save=False): + run_notebook("agentchat_hierarchy_flow_using_select_speaker.ipynb", save=save) + + +if __name__ == "__main__": + test_agentchat_auto_feedback_from_code(save=True) + # test_oai_chatgpt_gpt4(save=True) + # test_oai_completion(save=True) + # test_agentchat_MathChat(save=True) + # test_agentchat_function_call(save=True)