From e89ec5e6c0d9b9b703f721752c3d496edfb314d8 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Mon, 26 Feb 2024 15:38:48 -0500 Subject: [PATCH 01/19] init PR --- autogen/agentchat/groupchat.py | 34 +- notebook/agentchat_groupchat_customized.ipynb | 439 ++++++++++++++++++ 2 files changed, 472 insertions(+), 1 deletion(-) create mode 100644 notebook/agentchat_groupchat_customized.ipynb diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 5997b093a362..ed524c7dede9 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -3,7 +3,7 @@ import re import sys from dataclasses import dataclass, field -from typing import Dict, List, Optional, Union, Tuple +from typing import Dict, List, Optional, Union, Tuple, Callable from ..code_utils import content_str @@ -36,6 +36,20 @@ class GroupChat: When set to True and when a message is a function call suggestion, the next speaker will be chosen from an agent which contains the corresponding function name in its `function_map`. + - customized_speaker_selection_func: pass a function to customize the speaker selection. Default is False. + customized_speaker_selection_func: + Parameters: + - last_speaker: Agent + The last speaker in the group chat. + - agents: List[Agents] + All agents in the group chat. + - messages: List[Dict] + All past messages in the group chat. + Returns: + - Agent + The selected speaker. + The return agent should be one of the agents in the group chat. + If the return agent is not valid, we will use default to the method specified in `speaker_selection_method`. - speaker_selection_method: the method for selecting the next speaker. Default is "auto". Could be any of the following (case insensitive), will raise ValueError if not recognized: - "auto": the next speaker is selected automatically by LLM. @@ -67,6 +81,7 @@ class GroupChat: max_round: Optional[int] = 10 admin_name: Optional[str] = "Admin" func_call_filter: Optional[bool] = True + customized_speaker_selection_func: Optional[Union[bool, Callable]] = False speaker_selection_method: Optional[str] = "auto" allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = None allowed_or_disallowed_speaker_transitions: Optional[Dict] = None @@ -156,6 +171,7 @@ def __post_init__(self): agents=self.agents, ) + @property def agent_names(self) -> List[str]: """Return the names of the agents in the group chat.""" @@ -387,6 +403,14 @@ def _prepare_and_select_agents( def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" + if self.customized_speaker_selection_func: + selected_agent = self.customized_speaker_selection_func(last_speaker, self.messages) + if selected_agent and selected_agent in self.agents: + return selected_agent + logger.warning( + f"Customized speaker selection failed to resolve the next speaker's name. Returned by the function: {selected_agent}. Default to `speaker_selection_method`: {self.speaker_selection_method}." + ) + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) if selected_agent: return selected_agent @@ -397,6 +421,14 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" + if self.customized_speaker_selection_func: + selected_agent = self.customized_speaker_selection_func(last_speaker, self.messages) + if selected_agent and selected_agent in self.agents: + return selected_agent + logger.warning( + f"Customized speaker selection failed to resolve the next speaker's name. Returned by the function: {selected_agent}. Default to `speaker_selection_method`: {self.speaker_selection_method}." + ) + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) if selected_agent: return selected_agent diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb new file mode 100644 index 000000000000..169c89cebad8 --- /dev/null +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -0,0 +1,439 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Group Chat with Customized Selection Method\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", + "In this notebook, we demonstrate how to pass a cumstomized agent selection method to GroupChat.\n", + "\n", + "````{=mdx}\n", + ":::info Requirements\n", + "Install `pyautogen`:\n", + "```bash\n", + "pip install pyautogen\n", + "```\n", + "\n", + "For more information, please refer to the [installation guide](/docs/installation/).\n", + ":::\n", + "````" + ] + }, + { + "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": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import autogen\n", + "\n", + "config_list = autogen.config_list_from_json(\n", + " \"OAI_CONFIG_LIST\",\n", + " filter_dict={\n", + " \"model\": [\"gpt-4\", \"gpt-4-1106-preview\"],\n", + " },\n", + ")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "````{=mdx}\n", + ":::tip\n", + "Learn more about configuring LLMs for agents [here](/docs/llm_configuration).\n", + ":::\n", + "````\n", + "\n", + "## Construct Agents\n", + "\n", + "- Planner: Give a plan and revise.\n", + "- Admin: Human in the loop to approve or terminate the process.\n", + "- Engineer: Retrieve papers from the internet by writing code.\n", + "- Executor: Execute the code.\n", + "- Scientist: Read the papers and write a summary.\n", + "\n", + "The basic pipeline is the following:\n", + "\n", + "1. The planner interact with Admin (user) to revise a plan. Only when the Admin types \"Approve\", we can move to the next step.\n", + "2. The engineer will write code to retrieve papers from the internet. The code will be executed by executor.\n", + "3. When the code is executed successfully, the scientist will read the papers and write a summary.\n", + "4. The summary will be reviewed by the Admin and give comments. When the Admin types \"TERMINATE\", the process will be terminated.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "gpt4_config = {\n", + " \"cache_seed\": 42, # change the cache_seed for different trials\n", + " \"temperature\": 0,\n", + " \"config_list\": config_list,\n", + " \"timeout\": 120,\n", + "}\n", + "\n", + "planner = autogen.AssistantAgent(\n", + " name=\"Planner\",\n", + " system_message=\"\"\"Planner. Suggest a plan. Revise the plan based on feedback from admin and critic, until admin approval.\n", + "The plan may involve an engineer who can write code and a scientist who doesn't write code.\n", + "Explain the plan first. Be clear which step is performed by an engineer, and which step is performed by a scientist.\n", + "\"\"\",\n", + " llm_config=gpt4_config,\n", + ")\n", + "\n", + "user_proxy = autogen.UserProxyAgent(\n", + " name=\"Admin\",\n", + " system_message=\"A human admin. Interact with the planner to discuss the plan. Plan execution needs to be approved by this admin.\",\n", + " code_execution_config=False,\n", + ")\n", + "\n", + "engineer = autogen.AssistantAgent(\n", + " name=\"Engineer\",\n", + " llm_config=gpt4_config,\n", + " system_message=\"\"\"Engineer. You follow an approved plan. You write python/shell code to solve tasks. Wrap the code in a code block that specifies the script type. The user can't modify your code. So do not suggest incomplete code which requires others to modify. Don't use a code block if it's not intended to be executed by the executor.\n", + "Don't include multiple code blocks in one response. Do not ask others to copy and paste the result. Check the execution result returned by the executor.\n", + "If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try.\n", + "\"\"\",\n", + ")\n", + "scientist = autogen.AssistantAgent(\n", + " name=\"Scientist\",\n", + " llm_config=gpt4_config,\n", + " system_message=\"\"\"Scientist. You follow an approved plan. You are able to categorize papers after seeing their abstracts printed. You don't write code.\"\"\",\n", + ")\n", + "\n", + "executor = autogen.UserProxyAgent(\n", + " name=\"Executor\",\n", + " system_message=\"Executor. Execute the code written by the engineer and report the result.\",\n", + " human_input_mode=\"NEVER\",\n", + " code_execution_config={\n", + " \"last_n_messages\": 3,\n", + " \"work_dir\": \"paper\",\n", + " \"use_docker\": False,\n", + " }, # Please set use_docker=True if docker is available to run the generated code. Using docker is safer than running the generated code directly.\n", + ")\n", + "\n", + "from autogen import Agent\n", + "from typing import List, Dict\n", + "def customized_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", + " \"\"\"Define a customized speaker selection function.\n", + " A recommended way is to define a transtion for each speaker in the groupchat.\n", + " \"\"\"\n", + " if len(messages) <= 1:\n", + " return planner\n", + " \n", + " if last_speaker is user_proxy:\n", + " if \"Approve\" in messages[-1][\"content\"]:\n", + " # If the last message is approved, let the engineer to speak\n", + " return engineer\n", + " elif messages[-2]['name'] == \"Planner\":\n", + " # If it is the planning stage, let the planner to continue\n", + " return planner\n", + " elif messages[-2]['name'] == \"Scientist\":\n", + " # If the last message is from the scientist, let the scientist to continue\n", + " return scientist\n", + "\n", + " elif last_speaker is planner:\n", + " # Always let the user to speak after the planner\n", + " return user_proxy\n", + " \n", + " elif last_speaker is engineer:\n", + " if \"```python\" in messages[-1][\"content\"]:\n", + " # If the last message is a python code block, let the executor to speak\n", + " return executor\n", + " else:\n", + " # Otherwise, let the engineer to continue\n", + " return engineer\n", + " \n", + " elif last_speaker is executor:\n", + " if \"exitcode: 1\" in messages[-1][\"content\"]:\n", + " # If the last message indicates an error, let the engineer to improve the code\n", + " return engineer\n", + " else:\n", + " # Otherwise, let the scientist to speak\n", + " return scientist\n", + " \n", + " elif last_speaker is scientist:\n", + " # Always let the user to speak after the scientist\n", + " return user_proxy\n", + "\n", + "\n", + "groupchat = autogen.GroupChat(\n", + " agents=[user_proxy, engineer, scientist, planner, executor], \n", + " messages=[],\n", + " max_round=20,\n", + " customized_speaker_selection_func=customized_speaker_selection_func,\n", + ")\n", + "manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=gpt4_config)" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Start Chat" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[33mAdmin\u001b[0m (to chat_manager):\n", + "\n", + "Find a latest paper about gpt-4 on arxiv and find its potential applications in software.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mPlanner\u001b[0m (to chat_manager):\n", + "\n", + "**Initial Plan:**\n", + "\n", + "1. **Scientist's Task: Literature Review**\n", + " - The scientist will conduct a comprehensive literature review to find the latest paper about GPT-4 on arXiv. This involves using search queries related to GPT-4 and filtering results by the most recent publications.\n", + "\n", + "2. **Scientist's Task: Analysis of the Paper**\n", + " - Once the latest paper is identified, the scientist will read through the paper to understand its contents, focusing on the methodology, results, and discussions about potential applications in software.\n", + "\n", + "3. **Scientist's Task: Identifying Potential Applications**\n", + " - The scientist will then brainstorm and list potential applications of GPT-4 in software, based on the findings from the paper. This may include applications in natural language processing, code generation, chatbots, and more.\n", + "\n", + "4. **Engineer's Task: Technical Feasibility Assessment**\n", + " - The engineer will review the list of potential applications provided by the scientist and assess the technical feasibility of each application. This involves considering the current state of software technology, the capabilities of GPT-4, and the practicality of integrating GPT-4 into existing systems.\n", + "\n", + "5. **Engineer's Task: Prototype Development Plan**\n", + " - For applications deemed technically feasible, the engineer will draft a plan for developing a prototype that demonstrates the use of GPT-4 in a software application. This plan will outline the required resources, estimated timeline, and the steps for implementation.\n", + "\n", + "6. **Joint Task: Finalizing the Plan**\n", + " - The scientist and engineer will collaborate to finalize the plan, ensuring that it is scientifically sound and technically viable. They will prepare a document detailing the plan for potential applications and the prototype development.\n", + "\n", + "7. **Presentation to Admin**\n", + " - The finalized plan will be presented to the admin for approval. The admin will review the plan and provide feedback.\n", + "\n", + "8. **Revisions Based on Feedback**\n", + " - Based on the admin's feedback, the scientist and engineer will make necessary revisions to the plan. This iterative process will continue until the admin approves the plan.\n", + "\n", + "**Awaiting Admin's Feedback:** Please review the initial plan and provide feedback on any adjustments or additional details you would like to see.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mAdmin\u001b[0m (to chat_manager):\n", + "\n", + "Approve\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mEngineer\u001b[0m (to chat_manager):\n", + "\n", + "Since the plan has been approved, I will now proceed with the first step, which is to find the latest paper about GPT-4 on arXiv. To do this, I will write a Python script that uses the arXiv API to search for papers related to GPT-4 and filter them by the most recent publications.\n", + "\n", + "Here is the Python script that accomplishes this task:\n", + "\n", + "```python\n", + "import requests\n", + "from datetime import datetime\n", + "\n", + "# Define the URL for the arXiv API\n", + "ARXIV_API_URL = \"http://export.arxiv.org/api/query\"\n", + "\n", + "# Define the search parameters\n", + "search_query = \"all:gpt-4\"\n", + "start = 0\n", + "max_results = 1\n", + "sort_by = \"submittedDate\"\n", + "sort_order = \"descending\"\n", + "\n", + "# Construct the query\n", + "query_params = {\n", + " \"search_query\": search_query,\n", + " \"start\": start,\n", + " \"max_results\": max_results,\n", + " \"sortBy\": sort_by,\n", + " \"sortOrder\": sort_order\n", + "}\n", + "\n", + "# Send the request to the arXiv API\n", + "response = requests.get(ARXIV_API_URL, params=query_params)\n", + "\n", + "# Check if the request was successful\n", + "if response.status_code == 200:\n", + " # Parse the response\n", + " feed = response.text\n", + " # Find the entry element, which contains the paper information\n", + " start_entry = feed.find('')\n", + " end_entry = feed.find('')\n", + " entry = feed[start_entry:end_entry]\n", + " \n", + " # Extract the title\n", + " start_title = entry.find('') + 7\n", + " end_title = entry.find('')\n", + " title = entry[start_title:end_title].strip()\n", + " \n", + " # Extract the published date\n", + " start_published = entry.find('') + 12\n", + " end_published = entry.find('')\n", + " published = entry[start_published:end_published].strip()\n", + " \n", + " # Extract the summary\n", + " start_summary = entry.find('') + 9\n", + " end_summary = entry.find('')\n", + " summary = entry[start_summary:end_summary].strip()\n", + " \n", + " # Extract the authors\n", + " authors = []\n", + " start_author = entry.find('')\n", + " end_author = entry.find('')\n", + " while start_author != -1 and end_author != -1:\n", + " start_name = entry.find('', start_author) + 6\n", + " end_name = entry.find('', start_author)\n", + " author_name = entry[start_name:end_name].strip()\n", + " authors.append(author_name)\n", + " start_author = entry.find('', end_author)\n", + " end_author = entry.find('', start_author)\n", + " \n", + " # Print the results\n", + " print(f\"Title: {title}\")\n", + " print(f\"Published Date: {published}\")\n", + " print(f\"Authors: {', '.join(authors)}\")\n", + " print(f\"Summary: {summary}\")\n", + "else:\n", + " print(\"Failed to retrieve data from arXiv API.\")\n", + "```\n", + "\n", + "This script will output the title, published date, authors, and summary of the most recent paper related to GPT-4 on arXiv. Please note that the actual content of the paper and its potential applications in software will need to be analyzed manually after retrieving the paper information.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[31m\n", + ">>>>>>>> EXECUTING CODE BLOCK 0 (inferred language is python)...\u001b[0m\n", + "\u001b[33mExecutor\u001b[0m (to chat_manager):\n", + "\n", + "exitcode: 0 (execution succeeded)\n", + "Code output: \n", + "Title: A Data-Centric Approach To Generate Faithful and High Quality Patient\n", + " Summaries with Large Language Models\n", + "Published Date: 024-02-23T16:32:28Z\n", + "Authors: Stefan Hegselmann, Shannon Zejiang Shen, Florian Gierse, Monica Agrawal, David Sontag, Xiaoyi Jiang\n", + "Summary: Patients often face difficulties in understanding their hospitalizations,\n", + "while healthcare workers have limited resources to provide explanations. In\n", + "this work, we investigate the potential of large language models to generate\n", + "patient summaries based on doctors' notes and study the effect of training data\n", + "on the faithfulness and quality of the generated summaries. To this end, we\n", + "develop a rigorous labeling protocol for hallucinations, and have two medical\n", + "experts annotate 100 real-world summaries and 100 generated summaries. We show\n", + "that fine-tuning on hallucination-free data effectively reduces hallucinations\n", + "from 2.60 to 1.55 per summary for Llama 2, while preserving relevant\n", + "information. Although the effect is still present, it is much smaller for GPT-4\n", + "when prompted with five examples (0.70 to 0.40). We also conduct a qualitative\n", + "evaluation using hallucination-free and improved training data. GPT-4 shows\n", + "very good results even in the zero-shot setting. We find that common\n", + "quantitative metrics do not correlate well with faithfulness and quality.\n", + "Finally, we test GPT-4 for automatic hallucination detection, which yields\n", + "promising results.\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mScientist\u001b[0m (to chat_manager):\n", + "\n", + "Based on the abstract provided, the paper titled \"A Data-Centric Approach To Generate Faithful and High Quality Patient Summaries with Large Language Models\" explores the use of large language models, including GPT-4, to generate patient summaries from doctors' notes. The study focuses on the impact of training data on the faithfulness and quality of the generated summaries and also investigates the potential of GPT-4 for automatic hallucination detection.\n", + "\n", + "**Potential Applications in Software:**\n", + "\n", + "1. **Healthcare Documentation Automation:**\n", + " - GPT-4 could be used to develop software that assists healthcare professionals in creating accurate and comprehensive patient summaries by automatically processing doctors' notes and other medical records.\n", + "\n", + "2. **Clinical Decision Support Systems:**\n", + " - Integrating GPT-4 into clinical decision support systems could provide healthcare workers with insights and suggestions based on a patient's medical history, potentially improving diagnosis and treatment planning.\n", + "\n", + "3. **Patient Education and Communication:**\n", + " - Software applications could leverage GPT-4 to translate complex medical information into patient-friendly summaries, enhancing patient understanding of their health conditions and treatments.\n", + "\n", + "4. **Medical Training and Simulation:**\n", + " - GPT-4 could be used to create realistic medical scenarios for training medical students and professionals, simulating patient interactions and generating case studies.\n", + "\n", + "5. **Data Quality Assurance:**\n", + " - The paper suggests that GPT-4 can be used for automatic hallucination detection, which refers to the identification of inaccuracies or fabrications in generated text. This could be applied to software that ensures the quality and reliability of medical documentation.\n", + "\n", + "6. **Research and Development:**\n", + " - GPT-4 could assist researchers in summarizing and synthesizing large volumes of medical literature, aiding in the discovery of new insights and the development of novel treatments.\n", + "\n", + "7. **Personalized Health Monitoring:**\n", + " - Software applications could use GPT-4 to provide personalized health monitoring and advice by analyzing user input, such as symptoms or lifestyle factors, and generating tailored health recommendations.\n", + "\n", + "These potential applications highlight the versatility of GPT-4 in the realm of healthcare software, offering opportunities to enhance patient care, improve healthcare workflows, and support medical education and research.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "\u001b[33mAdmin\u001b[0m (to chat_manager):\n", + "\n", + "TERMINATE\n", + "\n", + "--------------------------------------------------------------------------------\n" + ] + }, + { + "data": { + "text/plain": [ + "ChatResult(chat_id=None, chat_history=[{'content': 'Find a latest paper about gpt-4 on arxiv and find its potential applications in software.', 'role': 'assistant'}, {'content': \"**Initial Plan:**\\n\\n1. **Scientist's Task: Literature Review**\\n - The scientist will conduct a comprehensive literature review to find the latest paper about GPT-4 on arXiv. This involves using search queries related to GPT-4 and filtering results by the most recent publications.\\n\\n2. **Scientist's Task: Analysis of the Paper**\\n - Once the latest paper is identified, the scientist will read through the paper to understand its contents, focusing on the methodology, results, and discussions about potential applications in software.\\n\\n3. **Scientist's Task: Identifying Potential Applications**\\n - The scientist will then brainstorm and list potential applications of GPT-4 in software, based on the findings from the paper. This may include applications in natural language processing, code generation, chatbots, and more.\\n\\n4. **Engineer's Task: Technical Feasibility Assessment**\\n - The engineer will review the list of potential applications provided by the scientist and assess the technical feasibility of each application. This involves considering the current state of software technology, the capabilities of GPT-4, and the practicality of integrating GPT-4 into existing systems.\\n\\n5. **Engineer's Task: Prototype Development Plan**\\n - For applications deemed technically feasible, the engineer will draft a plan for developing a prototype that demonstrates the use of GPT-4 in a software application. This plan will outline the required resources, estimated timeline, and the steps for implementation.\\n\\n6. **Joint Task: Finalizing the Plan**\\n - The scientist and engineer will collaborate to finalize the plan, ensuring that it is scientifically sound and technically viable. They will prepare a document detailing the plan for potential applications and the prototype development.\\n\\n7. **Presentation to Admin**\\n - The finalized plan will be presented to the admin for approval. The admin will review the plan and provide feedback.\\n\\n8. **Revisions Based on Feedback**\\n - Based on the admin's feedback, the scientist and engineer will make necessary revisions to the plan. This iterative process will continue until the admin approves the plan.\\n\\n**Awaiting Admin's Feedback:** Please review the initial plan and provide feedback on any adjustments or additional details you would like to see.\", 'name': 'Planner', 'role': 'user'}, {'content': 'Approve', 'role': 'assistant'}, {'content': 'Since the plan has been approved, I will now proceed with the first step, which is to find the latest paper about GPT-4 on arXiv. To do this, I will write a Python script that uses the arXiv API to search for papers related to GPT-4 and filter them by the most recent publications.\\n\\nHere is the Python script that accomplishes this task:\\n\\n```python\\nimport requests\\nfrom datetime import datetime\\n\\n# Define the URL for the arXiv API\\nARXIV_API_URL = \"http://export.arxiv.org/api/query\"\\n\\n# Define the search parameters\\nsearch_query = \"all:gpt-4\"\\nstart = 0\\nmax_results = 1\\nsort_by = \"submittedDate\"\\nsort_order = \"descending\"\\n\\n# Construct the query\\nquery_params = {\\n \"search_query\": search_query,\\n \"start\": start,\\n \"max_results\": max_results,\\n \"sortBy\": sort_by,\\n \"sortOrder\": sort_order\\n}\\n\\n# Send the request to the arXiv API\\nresponse = requests.get(ARXIV_API_URL, params=query_params)\\n\\n# Check if the request was successful\\nif response.status_code == 200:\\n # Parse the response\\n feed = response.text\\n # Find the entry element, which contains the paper information\\n start_entry = feed.find(\\'\\')\\n end_entry = feed.find(\\'\\')\\n entry = feed[start_entry:end_entry]\\n \\n # Extract the title\\n start_title = entry.find(\\'\\') + 7\\n end_title = entry.find(\\'\\')\\n title = entry[start_title:end_title].strip()\\n \\n # Extract the published date\\n start_published = entry.find(\\'\\') + 12\\n end_published = entry.find(\\'\\')\\n published = entry[start_published:end_published].strip()\\n \\n # Extract the summary\\n start_summary = entry.find(\\'\\') + 9\\n end_summary = entry.find(\\'\\')\\n summary = entry[start_summary:end_summary].strip()\\n \\n # Extract the authors\\n authors = []\\n start_author = entry.find(\\'\\')\\n end_author = entry.find(\\'\\')\\n while start_author != -1 and end_author != -1:\\n start_name = entry.find(\\'\\', start_author) + 6\\n end_name = entry.find(\\'\\', start_author)\\n author_name = entry[start_name:end_name].strip()\\n authors.append(author_name)\\n start_author = entry.find(\\'\\', end_author)\\n end_author = entry.find(\\'\\', start_author)\\n \\n # Print the results\\n print(f\"Title: {title}\")\\n print(f\"Published Date: {published}\")\\n print(f\"Authors: {\\', \\'.join(authors)}\")\\n print(f\"Summary: {summary}\")\\nelse:\\n print(\"Failed to retrieve data from arXiv API.\")\\n```\\n\\nThis script will output the title, published date, authors, and summary of the most recent paper related to GPT-4 on arXiv. Please note that the actual content of the paper and its potential applications in software will need to be analyzed manually after retrieving the paper information.', 'name': 'Engineer', 'role': 'user'}, {'content': \"exitcode: 0 (execution succeeded)\\nCode output: \\nTitle: A Data-Centric Approach To Generate Faithful and High Quality Patient\\n Summaries with Large Language Models\\nPublished Date: 024-02-23T16:32:28Z\\nAuthors: Stefan Hegselmann, Shannon Zejiang Shen, Florian Gierse, Monica Agrawal, David Sontag, Xiaoyi Jiang\\nSummary: Patients often face difficulties in understanding their hospitalizations,\\nwhile healthcare workers have limited resources to provide explanations. In\\nthis work, we investigate the potential of large language models to generate\\npatient summaries based on doctors' notes and study the effect of training data\\non the faithfulness and quality of the generated summaries. To this end, we\\ndevelop a rigorous labeling protocol for hallucinations, and have two medical\\nexperts annotate 100 real-world summaries and 100 generated summaries. We show\\nthat fine-tuning on hallucination-free data effectively reduces hallucinations\\nfrom 2.60 to 1.55 per summary for Llama 2, while preserving relevant\\ninformation. Although the effect is still present, it is much smaller for GPT-4\\nwhen prompted with five examples (0.70 to 0.40). We also conduct a qualitative\\nevaluation using hallucination-free and improved training data. GPT-4 shows\\nvery good results even in the zero-shot setting. We find that common\\nquantitative metrics do not correlate well with faithfulness and quality.\\nFinally, we test GPT-4 for automatic hallucination detection, which yields\\npromising results.\\n\", 'name': 'Executor', 'role': 'user'}, {'content': 'Based on the abstract provided, the paper titled \"A Data-Centric Approach To Generate Faithful and High Quality Patient Summaries with Large Language Models\" explores the use of large language models, including GPT-4, to generate patient summaries from doctors\\' notes. The study focuses on the impact of training data on the faithfulness and quality of the generated summaries and also investigates the potential of GPT-4 for automatic hallucination detection.\\n\\n**Potential Applications in Software:**\\n\\n1. **Healthcare Documentation Automation:**\\n - GPT-4 could be used to develop software that assists healthcare professionals in creating accurate and comprehensive patient summaries by automatically processing doctors\\' notes and other medical records.\\n\\n2. **Clinical Decision Support Systems:**\\n - Integrating GPT-4 into clinical decision support systems could provide healthcare workers with insights and suggestions based on a patient\\'s medical history, potentially improving diagnosis and treatment planning.\\n\\n3. **Patient Education and Communication:**\\n - Software applications could leverage GPT-4 to translate complex medical information into patient-friendly summaries, enhancing patient understanding of their health conditions and treatments.\\n\\n4. **Medical Training and Simulation:**\\n - GPT-4 could be used to create realistic medical scenarios for training medical students and professionals, simulating patient interactions and generating case studies.\\n\\n5. **Data Quality Assurance:**\\n - The paper suggests that GPT-4 can be used for automatic hallucination detection, which refers to the identification of inaccuracies or fabrications in generated text. This could be applied to software that ensures the quality and reliability of medical documentation.\\n\\n6. **Research and Development:**\\n - GPT-4 could assist researchers in summarizing and synthesizing large volumes of medical literature, aiding in the discovery of new insights and the development of novel treatments.\\n\\n7. **Personalized Health Monitoring:**\\n - Software applications could use GPT-4 to provide personalized health monitoring and advice by analyzing user input, such as symptoms or lifestyle factors, and generating tailored health recommendations.\\n\\nThese potential applications highlight the versatility of GPT-4 in the realm of healthcare software, offering opportunities to enhance patient care, improve healthcare workflows, and support medical education and research.', 'name': 'Scientist', 'role': 'user'}, {'content': 'TERMINATE', 'role': 'assistant'}], summary='', cost=({'total_cost': 0}, {'total_cost': 0}), human_input=['Approve', 'TERMINATE'])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "user_proxy.initiate_chat(\n", + " manager, message=\"Find a latest paper about gpt-4 on arxiv and find its potential applications in software.\"\n", + ")\n", + "# type exit to terminate the chat" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "flaml", + "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.9.18" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 405c5003305b2f699d6003a884abdda512edf6ad Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 10:46:37 -0500 Subject: [PATCH 02/19] update --- autogen/agentchat/groupchat.py | 14 +++--- notebook/agentchat_groupchat_customized.ipynb | 8 ++-- test/agentchat/test_groupchat.py | 44 ++++++++++++++++++- 3 files changed, 54 insertions(+), 12 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index ed524c7dede9..8a7dd97cc718 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -36,8 +36,8 @@ class GroupChat: When set to True and when a message is a function call suggestion, the next speaker will be chosen from an agent which contains the corresponding function name in its `function_map`. - - customized_speaker_selection_func: pass a function to customize the speaker selection. Default is False. - customized_speaker_selection_func: + - custom_speaker_selection_func: pass a function to customize the speaker selection. Default is None. + custom_speaker_selection_func: Parameters: - last_speaker: Agent The last speaker in the group chat. @@ -81,7 +81,7 @@ class GroupChat: max_round: Optional[int] = 10 admin_name: Optional[str] = "Admin" func_call_filter: Optional[bool] = True - customized_speaker_selection_func: Optional[Union[bool, Callable]] = False + custom_speaker_selection_func: Optional[Callable] = None speaker_selection_method: Optional[str] = "auto" allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = None allowed_or_disallowed_speaker_transitions: Optional[Dict] = None @@ -403,8 +403,8 @@ def _prepare_and_select_agents( def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - if self.customized_speaker_selection_func: - selected_agent = self.customized_speaker_selection_func(last_speaker, self.messages) + if self.custom_speaker_selection_func: + selected_agent = self.custom_speaker_selection_func(last_speaker, self.messages) if selected_agent and selected_agent in self.agents: return selected_agent logger.warning( @@ -421,8 +421,8 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - if self.customized_speaker_selection_func: - selected_agent = self.customized_speaker_selection_func(last_speaker, self.messages) + if self.custom_speaker_selection_func is not None: + selected_agent = self.custom_speaker_selection_func(last_speaker, self.messages) if selected_agent and selected_agent in self.agents: return selected_agent logger.warning( diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb index 169c89cebad8..55d0f4f2aead 100644 --- a/notebook/agentchat_groupchat_customized.ipynb +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -5,7 +5,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Group Chat with Customized Selection Method\n", + "# Group Chat with Customized Speaker Selection Method\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", @@ -69,7 +69,7 @@ "- Executor: Execute the code.\n", "- Scientist: Read the papers and write a summary.\n", "\n", - "The basic pipeline is the following:\n", + "The pipeline is the following:\n", "\n", "1. The planner interact with Admin (user) to revise a plan. Only when the Admin types \"Approve\", we can move to the next step.\n", "2. The engineer will write code to retrieve papers from the internet. The code will be executed by executor.\n", @@ -132,7 +132,7 @@ "\n", "from autogen import Agent\n", "from typing import List, Dict\n", - "def customized_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", + "def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", " \"\"\"Define a customized speaker selection function.\n", " A recommended way is to define a transtion for each speaker in the groupchat.\n", " \"\"\"\n", @@ -179,7 +179,7 @@ " agents=[user_proxy, engineer, scientist, planner, executor], \n", " messages=[],\n", " max_round=20,\n", - " customized_speaker_selection_func=customized_speaker_selection_func,\n", + " custom_speaker_selection_func=custom_speaker_selection_func,\n", ")\n", "manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=gpt4_config)" ] diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 1c16e6778609..0339e7796b86 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 -m pytest from typing import Any, Dict, List, Optional, Type -from autogen import AgentNameConflict +from autogen import AgentNameConflict, Agent import pytest from unittest import mock import builtins @@ -909,6 +909,48 @@ def chat(gc_manager: autogen.GroupChatManager): assert msg["content"] == team1_msg["content"] assert reply["content"] == team2_msg["content"] +def test_customized_chat(): + + a1 = autogen.UserProxyAgent( + name="a1", + default_auto_reply="This is a1 speaking.", + human_input_mode="NEVER", + code_execution_config={}, + ) + + a2 = autogen.UserProxyAgent( + name="a2", + default_auto_reply="This is a2 speaking.", + human_input_mode="NEVER", + code_execution_config={}, + ) + + a3 = autogen.UserProxyAgent( + name="a3", + default_auto_reply="TERMINATE", + human_input_mode="NEVER", + code_execution_config={}, + ) + + def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): + """Define a customized speaker selection function. + A recommended way is to define a transtion for each speaker in the groupchat. + """ + if last_speaker is a1: + return a2 + elif last_speaker is a2: + return a3 + + groupchat = autogen.GroupChat( + agents=[a1, a2, a3], + messages=[], + max_round=20, + custom_speaker_selection_func=custom_speaker_selection_func, + ) + manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) + + a1.initiate_chat(manager, message="Hello, this is a1 speaking.") + if __name__ == "__main__": # test_func_call_groupchat() From 6786cc2bdd0a77d04870bc710c08e4c7b803ce6d Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 10:51:53 -0500 Subject: [PATCH 03/19] update code check --- autogen/agentchat/groupchat.py | 3 +- notebook/agentchat_custom_model.ipynb | 1 + notebook/agentchat_groupchat_customized.ipynb | 18 +++++++----- notebook/agentchat_lmm_gpt-4v.ipynb | 2 -- test/agentchat/test_groupchat.py | 29 +++++++++---------- 5 files changed, 26 insertions(+), 27 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 8a7dd97cc718..45a108992036 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -48,7 +48,7 @@ class GroupChat: Returns: - Agent The selected speaker. - The return agent should be one of the agents in the group chat. + The return agent should be one of the agents in the group chat. If the return agent is not valid, we will use default to the method specified in `speaker_selection_method`. - speaker_selection_method: the method for selecting the next speaker. Default is "auto". Could be any of the following (case insensitive), will raise ValueError if not recognized: @@ -171,7 +171,6 @@ def __post_init__(self): agents=self.agents, ) - @property def agent_names(self) -> List[str]: """Return the names of the agents in the group chat.""" diff --git a/notebook/agentchat_custom_model.ipynb b/notebook/agentchat_custom_model.ipynb index 8af9ebf1f50a..6a42906743f2 100644 --- a/notebook/agentchat_custom_model.ipynb +++ b/notebook/agentchat_custom_model.ipynb @@ -383,6 +383,7 @@ "source": [ "# load model here\n", "\n", + "\n", "config = config_list_custom[0]\n", "device = config.get(\"device\", \"cpu\")\n", "loaded_model = AutoModelForCausalLM.from_pretrained(config[\"model\"]).to(device)\n", diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb index 55d0f4f2aead..4d24efe59693 100644 --- a/notebook/agentchat_groupchat_customized.ipynb +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -132,28 +132,30 @@ "\n", "from autogen import Agent\n", "from typing import List, Dict\n", + "\n", + "\n", "def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", " \"\"\"Define a customized speaker selection function.\n", - " A recommended way is to define a transtion for each speaker in the groupchat.\n", + " A recommended way is to define a transition for each speaker in the groupchat.\n", " \"\"\"\n", " if len(messages) <= 1:\n", " return planner\n", - " \n", + "\n", " if last_speaker is user_proxy:\n", " if \"Approve\" in messages[-1][\"content\"]:\n", " # If the last message is approved, let the engineer to speak\n", " return engineer\n", - " elif messages[-2]['name'] == \"Planner\":\n", + " elif messages[-2][\"name\"] == \"Planner\":\n", " # If it is the planning stage, let the planner to continue\n", " return planner\n", - " elif messages[-2]['name'] == \"Scientist\":\n", + " elif messages[-2][\"name\"] == \"Scientist\":\n", " # If the last message is from the scientist, let the scientist to continue\n", " return scientist\n", "\n", " elif last_speaker is planner:\n", " # Always let the user to speak after the planner\n", " return user_proxy\n", - " \n", + "\n", " elif last_speaker is engineer:\n", " if \"```python\" in messages[-1][\"content\"]:\n", " # If the last message is a python code block, let the executor to speak\n", @@ -161,7 +163,7 @@ " else:\n", " # Otherwise, let the engineer to continue\n", " return engineer\n", - " \n", + "\n", " elif last_speaker is executor:\n", " if \"exitcode: 1\" in messages[-1][\"content\"]:\n", " # If the last message indicates an error, let the engineer to improve the code\n", @@ -169,14 +171,14 @@ " else:\n", " # Otherwise, let the scientist to speak\n", " return scientist\n", - " \n", + "\n", " elif last_speaker is scientist:\n", " # Always let the user to speak after the scientist\n", " return user_proxy\n", "\n", "\n", "groupchat = autogen.GroupChat(\n", - " agents=[user_proxy, engineer, scientist, planner, executor], \n", + " agents=[user_proxy, engineer, scientist, planner, executor],\n", " messages=[],\n", " max_round=20,\n", " custom_speaker_selection_func=custom_speaker_selection_func,\n", diff --git a/notebook/agentchat_lmm_gpt-4v.ipynb b/notebook/agentchat_lmm_gpt-4v.ipynb index c56c6e6a1db7..b49f4472a504 100644 --- a/notebook/agentchat_lmm_gpt-4v.ipynb +++ b/notebook/agentchat_lmm_gpt-4v.ipynb @@ -637,8 +637,6 @@ } ], "source": [ - "\n", - "\n", "creator = FigureCreator(name=\"Figure Creator~\", llm_config=gpt4_llm_config)\n", "\n", "user_proxy = autogen.UserProxyAgent(\n", diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 0339e7796b86..bd5994e039c8 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -1,14 +1,13 @@ #!/usr/bin/env python3 -m pytest from typing import Any, Dict, List, Optional, Type -from autogen import AgentNameConflict, Agent +from autogen import AgentNameConflict, Agent, GroupChat import pytest from unittest import mock import builtins import autogen import json import sys -from autogen import Agent, GroupChat def test_func_call_groupchat(): @@ -909,40 +908,40 @@ def chat(gc_manager: autogen.GroupChatManager): assert msg["content"] == team1_msg["content"] assert reply["content"] == team2_msg["content"] -def test_customized_chat(): +def test_customized_chat(): a1 = autogen.UserProxyAgent( - name="a1", - default_auto_reply="This is a1 speaking.", - human_input_mode="NEVER", - code_execution_config={}, - ) + name="a1", + default_auto_reply="This is a1 speaking.", + human_input_mode="NEVER", + code_execution_config={}, + ) a2 = autogen.UserProxyAgent( name="a2", default_auto_reply="This is a2 speaking.", - human_input_mode="NEVER", - code_execution_config={}, + human_input_mode="NEVER", + code_execution_config={}, ) a3 = autogen.UserProxyAgent( name="a3", default_auto_reply="TERMINATE", - human_input_mode="NEVER", - code_execution_config={}, + human_input_mode="NEVER", + code_execution_config={}, ) def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): """Define a customized speaker selection function. - A recommended way is to define a transtion for each speaker in the groupchat. + A recommended way is to define a transition for each speaker in the groupchat. """ if last_speaker is a1: return a2 elif last_speaker is a2: return a3 - + groupchat = autogen.GroupChat( - agents=[a1, a2, a3], + agents=[a1, a2, a3], messages=[], max_round=20, custom_speaker_selection_func=custom_speaker_selection_func, From 81e9ff0e9ae3a6113af29e67c441ced602b48aac Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 15:41:21 -0500 Subject: [PATCH 04/19] update --- autogen/agentchat/groupchat.py | 90 +++++++++++-------- notebook/agentchat_groupchat_customized.ipynb | 12 ++- test/agentchat/test_groupchat.py | 2 +- 3 files changed, 61 insertions(+), 43 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 45a108992036..55b972d24d1a 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -36,26 +36,21 @@ class GroupChat: When set to True and when a message is a function call suggestion, the next speaker will be chosen from an agent which contains the corresponding function name in its `function_map`. - - custom_speaker_selection_func: pass a function to customize the speaker selection. Default is None. - custom_speaker_selection_func: - Parameters: - - last_speaker: Agent - The last speaker in the group chat. - - agents: List[Agents] - All agents in the group chat. - - messages: List[Dict] - All past messages in the group chat. - Returns: - - Agent - The selected speaker. - The return agent should be one of the agents in the group chat. - If the return agent is not valid, we will use default to the method specified in `speaker_selection_method`. - speaker_selection_method: the method for selecting the next speaker. Default is "auto". Could be any of the following (case insensitive), will raise ValueError if not recognized: - "auto": the next speaker is selected automatically by LLM. - "manual": the next speaker is selected manually by user input. - "random": the next speaker is selected randomly. - "round_robin": the next speaker is selected in a round robin fashion, i.e., iterating in the same order as provided in `agents`. + - a customized speaker selection function: if passed in a function, it will be called with the following parameters: + custom_speaker_selection_func: + Parameters: + - last_speaker: Agent + The last speaker in the group chat. + - messages: List[Dict] + All past messages in the group chat. + Returns: + Return an `Agent` class or a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. @@ -81,7 +76,6 @@ class GroupChat: max_round: Optional[int] = 10 admin_name: Optional[str] = "Admin" func_call_filter: Optional[bool] = True - custom_speaker_selection_func: Optional[Callable] = None speaker_selection_method: Optional[str] = "auto" allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = None allowed_or_disallowed_speaker_transitions: Optional[Dict] = None @@ -292,11 +286,11 @@ def random_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A return random.choice(agents) def _prepare_and_select_agents( - self, last_speaker: Agent + self, last_speaker: Agent, speaker_selection_method: Optional[str], ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]: - if self.speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS: + if speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS: raise ValueError( - f"GroupChat speaker_selection_method is set to '{self.speaker_selection_method}'. " + f"GroupChat speaker_selection_method is set to '{speaker_selection_method}'. " f"It should be one of {self._VALID_SPEAKER_SELECTION_METHODS} (case insensitive). " ) @@ -315,7 +309,7 @@ def _prepare_and_select_agents( f"GroupChat is underpopulated with {n_agents} agents. " "Please add more agents to the GroupChat or use direct communication instead." ) - elif n_agents == 2 and self.speaker_selection_method.lower() != "round_robin" and allow_repeat_speaker: + elif n_agents == 2 and speaker_selection_method.lower() != "round_robin" and allow_repeat_speaker: logger.warning( f"GroupChat is underpopulated with {n_agents} agents. " "Consider setting speaker_selection_method to 'round_robin' or allow_repeat_speaker to False, " @@ -381,11 +375,11 @@ def _prepare_and_select_agents( # Use the selected speaker selection method select_speaker_messages = None - if self.speaker_selection_method.lower() == "manual": + if speaker_selection_method.lower() == "manual": selected_agent = self.manual_select_speaker(graph_eligible_agents) - elif self.speaker_selection_method.lower() == "round_robin": + elif speaker_selection_method.lower() == "round_robin": selected_agent = self.next_agent(last_speaker, graph_eligible_agents) - elif self.speaker_selection_method.lower() == "random": + elif speaker_selection_method.lower() == "random": selected_agent = self.random_select_speaker(graph_eligible_agents) else: selected_agent = None @@ -402,15 +396,24 @@ def _prepare_and_select_agents( def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - if self.custom_speaker_selection_func: - selected_agent = self.custom_speaker_selection_func(last_speaker, self.messages) - if selected_agent and selected_agent in self.agents: - return selected_agent - logger.warning( - f"Customized speaker selection failed to resolve the next speaker's name. Returned by the function: {selected_agent}. Default to `speaker_selection_method`: {self.speaker_selection_method}." - ) + if isinstance(self.speaker_selection_method, Callable): + selected_agent = self.speaker_selection_method(last_speaker, self.messages) + if isinstance(selected_agent, Agent): + if selected_agent in self.agents: + return selected_agent + else: + raise ValueError( + f"Custom speaker selection function returned an agent {selected_agent.name} not in the group chat." + ) + elif isinstance(selected_agent, str): + # If returned a string, assume it is a speaker selection method + temp_selection_method = selected_agent + else: + raise ValueError( + f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." + ) - selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: return selected_agent # auto speaker selection @@ -420,15 +423,24 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - if self.custom_speaker_selection_func is not None: - selected_agent = self.custom_speaker_selection_func(last_speaker, self.messages) - if selected_agent and selected_agent in self.agents: - return selected_agent - logger.warning( - f"Customized speaker selection failed to resolve the next speaker's name. Returned by the function: {selected_agent}. Default to `speaker_selection_method`: {self.speaker_selection_method}." - ) - - selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) + if isinstance(self.speaker_selection_method, Callable): + selected_agent = self.speaker_selection_method(last_speaker, self.messages) + if isinstance(selected_agent, Agent): + if selected_agent in self.agents: + return selected_agent + else: + raise ValueError( + f"Custom speaker selection function returned an agent {selected_agent.name} not in the group chat." + ) + elif isinstance(selected_agent, str): + # If returned a string, assume it is a speaker selection method + temp_selection_method = selected_agent + else: + raise ValueError( + f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." + ) + + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: return selected_agent # auto speaker selection diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb index 4d24efe59693..ec809259964e 100644 --- a/notebook/agentchat_groupchat_customized.ipynb +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -36,7 +36,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -79,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -137,6 +137,9 @@ "def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", " \"\"\"Define a customized speaker selection function.\n", " A recommended way is to define a transition for each speaker in the groupchat.\n", + "\n", + " Returns:\n", + " Return an `Agent` class or a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use.\n", " \"\"\"\n", " if len(messages) <= 1:\n", " return planner\n", @@ -176,12 +179,15 @@ " # Always let the user to speak after the scientist\n", " return user_proxy\n", "\n", + " else:\n", + " return \"random\"\n", + "\n", "\n", "groupchat = autogen.GroupChat(\n", " agents=[user_proxy, engineer, scientist, planner, executor],\n", " messages=[],\n", " max_round=20,\n", - " custom_speaker_selection_func=custom_speaker_selection_func,\n", + " speaker_selection_method=custom_speaker_selection_func,\n", ")\n", "manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=gpt4_config)" ] diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index bd5994e039c8..ca333640ca52 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -944,7 +944,7 @@ def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): agents=[a1, a2, a3], messages=[], max_round=20, - custom_speaker_selection_func=custom_speaker_selection_func, + speaker_selection_method=custom_speaker_selection_func, ) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) From ff0a8dedd5549feb3541038cfd0bbef4b3dfe5a4 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 15:43:03 -0500 Subject: [PATCH 05/19] update --- autogen/agentchat/groupchat.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 55b972d24d1a..e47d2d9173a9 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -286,7 +286,9 @@ def random_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A return random.choice(agents) def _prepare_and_select_agents( - self, last_speaker: Agent, speaker_selection_method: Optional[str], + self, + last_speaker: Agent, + speaker_selection_method: Optional[str], ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]: if speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS: raise ValueError( @@ -439,7 +441,7 @@ async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent raise ValueError( f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." ) - + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: return selected_agent From ae6c16790daf34302e1bd2bd3a2f8342b375fd33 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 17:32:32 -0500 Subject: [PATCH 06/19] update --- autogen/agentchat/groupchat.py | 46 ++++++++++++++++++---------------- 1 file changed, 24 insertions(+), 22 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index e47d2d9173a9..a6656401df25 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -76,7 +76,7 @@ class GroupChat: max_round: Optional[int] = 10 admin_name: Optional[str] = "Admin" func_call_filter: Optional[bool] = True - speaker_selection_method: Optional[str] = "auto" + speaker_selection_method: Optional[Union[str, Callable]] = "auto" allow_repeat_speaker: Optional[Union[bool, List[Agent]]] = None allowed_or_disallowed_speaker_transitions: Optional[Dict] = None speaker_transitions_type: Optional[str] = None @@ -288,7 +288,7 @@ def random_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A def _prepare_and_select_agents( self, last_speaker: Agent, - speaker_selection_method: Optional[str], + speaker_selection_method: str, ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]: if speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS: raise ValueError( @@ -396,8 +396,14 @@ def _prepare_and_select_agents( ] return selected_agent, graph_eligible_agents, select_speaker_messages - def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: - """Select the next speaker.""" + def _call_custom_speaker_selection_func(self, last_speaker: Agent) -> None: + """ + If self.speaker_selection_method is a function, call it to get the next speaker. + If self.speaker_selection_method is a string, return it. + + Return: + + """ if isinstance(self.speaker_selection_method, Callable): selected_agent = self.speaker_selection_method(last_speaker, self.messages) if isinstance(selected_agent, Agent): @@ -409,11 +415,20 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age ) elif isinstance(selected_agent, str): # If returned a string, assume it is a speaker selection method - temp_selection_method = selected_agent + return selected_agent else: raise ValueError( f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." ) + + return self.speaker_selection_method + + + def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: + """Select the next speaker.""" + temp_selection_method = self._call_custom_speaker_selection_func(last_speaker) + if isinstance(temp_selection_method, Agent): + return temp_selection_method selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: @@ -425,23 +440,10 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - if isinstance(self.speaker_selection_method, Callable): - selected_agent = self.speaker_selection_method(last_speaker, self.messages) - if isinstance(selected_agent, Agent): - if selected_agent in self.agents: - return selected_agent - else: - raise ValueError( - f"Custom speaker selection function returned an agent {selected_agent.name} not in the group chat." - ) - elif isinstance(selected_agent, str): - # If returned a string, assume it is a speaker selection method - temp_selection_method = selected_agent - else: - raise ValueError( - f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." - ) - + temp_selection_method = self._call_custom_speaker_selection_func(last_speaker) + if isinstance(temp_selection_method, Agent): + return temp_selection_method + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: return selected_agent From b259b84747ba9d08c64e64a2685864cfd61102e8 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Thu, 29 Feb 2024 17:39:58 -0500 Subject: [PATCH 07/19] update --- autogen/agentchat/groupchat.py | 7 +++---- test/agentchat/test_function_call_groupchat.py | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index a6656401df25..7be506a10acd 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -397,7 +397,7 @@ def _prepare_and_select_agents( return selected_agent, graph_eligible_agents, select_speaker_messages def _call_custom_speaker_selection_func(self, last_speaker: Agent) -> None: - """ + """ If self.speaker_selection_method is a function, call it to get the next speaker. If self.speaker_selection_method is a string, return it. @@ -420,9 +420,8 @@ def _call_custom_speaker_selection_func(self, last_speaker: Agent) -> None: raise ValueError( f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." ) - - return self.speaker_selection_method + return self.speaker_selection_method def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" @@ -443,7 +442,7 @@ async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent temp_selection_method = self._call_custom_speaker_selection_func(last_speaker) if isinstance(temp_selection_method, Agent): return temp_selection_method - + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) if selected_agent: return selected_agent diff --git a/test/agentchat/test_function_call_groupchat.py b/test/agentchat/test_function_call_groupchat.py index 0217f4cc6276..69b9a569ca83 100755 --- a/test/agentchat/test_function_call_groupchat.py +++ b/test/agentchat/test_function_call_groupchat.py @@ -131,7 +131,7 @@ def test_no_function_map(): ValueError, match="No agent can execute the function get_random_number. Please check the function_map of the agents.", ): - groupchat._prepare_and_select_agents(dummy2) + groupchat._prepare_and_select_agents(dummy2, speaker_selection_method="auto") if __name__ == "__main__": From 251cba60deea85ea5a70540c94ab0280767f501b Mon Sep 17 00:00:00 2001 From: Joshua Kim Date: Fri, 1 Mar 2024 08:43:10 +0000 Subject: [PATCH 08/19] Test the ability to have agents a,u,t,o,g,e,n speak in turn. --- test/agentchat/test_groupchat.py | 89 ++++++++++++++++++++++++++++++-- 1 file changed, 85 insertions(+), 4 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index ca333640ca52..90ddc5f1f28d 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -909,7 +909,7 @@ def chat(gc_manager: autogen.GroupChatManager): assert reply["content"] == team2_msg["content"] -def test_customized_chat(): +def test_custom_speaker_selection(): a1 = autogen.UserProxyAgent( name="a1", default_auto_reply="This is a1 speaking.", @@ -931,7 +931,7 @@ def test_customized_chat(): code_execution_config={}, ) - def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): + def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]) -> Agent: """Define a customized speaker selection function. A recommended way is to define a transition for each speaker in the groupchat. """ @@ -948,7 +948,87 @@ def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): ) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) - a1.initiate_chat(manager, message="Hello, this is a1 speaking.") + result = a1.initiate_chat(manager, message="Hello, this is a1 speaking.") + assert len(result.chat_history) == 3 + + +def test_custom_speaker_selection_with_transition_graph(): + """ + In this test, although speaker_selection_method is defined, the speaker transitions are also defined. + There are 26 agents here, a to z. + The speaker transitions are defined such that the agents can transition to the next alphabet. + In addition, because we want the transition order to be a,u,t,o,g,e,n, we also define the speaker transitions for these agents. + The speaker_selection_method is defined to return the next agent in the expected sequence. + """ + + # For loop that creates UserProxyAgent with names from a to z + agents = [ + autogen.UserProxyAgent( + name=chr(97 + i), + default_auto_reply=f"My name is {chr(97 + i)}", + human_input_mode="NEVER", + code_execution_config={}, + ) + for i in range(26) + ] + + # Print agents name + # print([agent.name for agent in agents]) + + # Initiate allowed speaker transitions + allowed_or_disallowed_speaker_transitions = {} + + # Each agent can transition to the next alphabet as a baseline + # Key is Agent, value is a list of Agents that the key Agent can transition to + for i in range(25): + allowed_or_disallowed_speaker_transitions[agents[i]] = [agents[i + 1]] + + # The test is to make sure that the agent sequence is a,u,t,o,g,e,n, so we need to add those transitions + expected_sequence = ["a", "u", "t", "o", "g", "e", "n"] + current_agent = None + previous_agent = None + + for char in expected_sequence: + # convert char to i so that we can use chr(97+i) + current_agent = agents[ord(char) - 97] + if previous_agent is not None: + # Add transition + allowed_or_disallowed_speaker_transitions[previous_agent].append(current_agent) + previous_agent = current_agent + + # For Kevin to visualize, to remove code + from autogen.graph_utils import visualize_speaker_transitions_dict + + visualize_speaker_transitions_dict(allowed_or_disallowed_speaker_transitions, agents) + + def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]) -> Agent: + """Define a customized speaker selection function. + A recommended way is to define a transition for each speaker in the groupchat. + """ + expected_sequence = ["a", "u", "t", "o", "g", "e", "n"] + + last_speaker_char = last_speaker.name + # Find the index of last_speaker_char in the expected_sequence + last_speaker_index = expected_sequence.index(last_speaker_char) + # Return the next agent in the expected sequence + if last_speaker_index == len(expected_sequence) - 1: + return None # ValueError: Custom speaker selection function returned an object of type instead of Agent or str. + else: + next_agent = agents[ord(expected_sequence[last_speaker_index + 1]) - 97] + return next_agent + + groupchat = autogen.GroupChat( + agents=agents, + messages=[], + max_round=20, + speaker_selection_method=custom_speaker_selection_func, + allowed_or_disallowed_speaker_transitions=allowed_or_disallowed_speaker_transitions, + speaker_transitions_type="allowed", + ) + manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) + + agents[0].initiate_chat(manager, message="My name is a") + # TODO: Assert result is a,u,t,o,g,e,n afterwards if __name__ == "__main__": @@ -961,7 +1041,8 @@ def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]): # test_agent_mentions() # test_termination() # test_next_agent() - test_send_intros() + # test_send_intros() # test_invalid_allow_repeat_speaker() # test_graceful_exit_before_max_round() # test_clear_agents_history() + test_custom_speaker_selection_with_transition_graph() From 0dbc08ae0a0570f6c7e3dace279a246b18a4590d Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Fri, 1 Mar 2024 19:50:18 -0500 Subject: [PATCH 09/19] update --- autogen/agentchat/groupchat.py | 6 +++--- notebook/agentchat_groupchat_customized.ipynb | 4 +++- setup.py | 1 + test/agentchat/test_groupchat.py | 4 ++-- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 2678393db8b8..39f71875b269 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -47,8 +47,8 @@ class GroupChat: Parameters: - last_speaker: Agent The last speaker in the group chat. - - messages: List[Dict] - All past messages in the group chat. + - groupchat: GroupChat + The GroupChat object Returns: Return an `Agent` class or a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. @@ -405,7 +405,7 @@ def _call_custom_speaker_selection_func(self, last_speaker: Agent) -> None: """ if isinstance(self.speaker_selection_method, Callable): - selected_agent = self.speaker_selection_method(last_speaker, self.messages) + selected_agent = self.speaker_selection_method(last_speaker, self) if isinstance(selected_agent, Agent): if selected_agent in self.agents: return selected_agent diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb index ec809259964e..2b141c5be04f 100644 --- a/notebook/agentchat_groupchat_customized.ipynb +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -134,13 +134,15 @@ "from typing import List, Dict\n", "\n", "\n", - "def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]):\n", + "def custom_speaker_selection_func(last_speaker: Agent, groupchat: autogen.GroupChat):\n", " \"\"\"Define a customized speaker selection function.\n", " A recommended way is to define a transition for each speaker in the groupchat.\n", "\n", " Returns:\n", " Return an `Agent` class or a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use.\n", " \"\"\"\n", + " messages = groupchat.messages\n", + "\n", " if len(messages) <= 1:\n", " return planner\n", "\n", diff --git a/setup.py b/setup.py index 4debf3c81e36..f15932fb4a18 100644 --- a/setup.py +++ b/setup.py @@ -45,6 +45,7 @@ "pre-commit", "pytest-asyncio", "pytest>=6.1.1,<8", + "networkx", ], "blendsearch": ["flaml[blendsearch]"], "mathchat": ["sympy", "pydantic==1.10.9", "wolframalpha"], diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 90ddc5f1f28d..5e7c08349522 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -931,7 +931,7 @@ def test_custom_speaker_selection(): code_execution_config={}, ) - def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]) -> Agent: + def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Agent: """Define a customized speaker selection function. A recommended way is to define a transition for each speaker in the groupchat. """ @@ -1001,7 +1001,7 @@ def test_custom_speaker_selection_with_transition_graph(): visualize_speaker_transitions_dict(allowed_or_disallowed_speaker_transitions, agents) - def custom_speaker_selection_func(last_speaker: Agent, messages: List[Dict]) -> Agent: + def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Agent: """Define a customized speaker selection function. A recommended way is to define a transition for each speaker in the groupchat. """ From 22b24d8717926bc63f36029a5e107c943ff54db3 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Fri, 1 Mar 2024 20:41:38 -0500 Subject: [PATCH 10/19] update --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index c02e7bc2eccd..9d4e2904fc64 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -41,7 +41,7 @@ jobs: python -m pip install --upgrade pip wheel pip install -e . python -c "import autogen" - pip install pytest mock + pip install pytest mock networkx - name: Install optional dependencies for code executors # code executors auto skip without deps, so only run for python 3.11 if: matrix.python-version == '3.11' From 7f18e83155303d3e06009af97f8776a126615e8c Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Fri, 1 Mar 2024 20:47:36 -0500 Subject: [PATCH 11/19] update --- .github/workflows/build.yml | 2 +- setup.py | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 9d4e2904fc64..cc9dd400e955 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -41,7 +41,7 @@ jobs: python -m pip install --upgrade pip wheel pip install -e . python -c "import autogen" - pip install pytest mock networkx + pip install pytest mock networkx matplotlib - name: Install optional dependencies for code executors # code executors auto skip without deps, so only run for python 3.11 if: matrix.python-version == '3.11' diff --git a/setup.py b/setup.py index f15932fb4a18..4debf3c81e36 100644 --- a/setup.py +++ b/setup.py @@ -45,7 +45,6 @@ "pre-commit", "pytest-asyncio", "pytest>=6.1.1,<8", - "networkx", ], "blendsearch": ["flaml[blendsearch]"], "mathchat": ["sympy", "pydantic==1.10.9", "wolframalpha"], From 8477c61db72d6728e08fbcf2631bdd697041e255 Mon Sep 17 00:00:00 2001 From: Joshua Kim Date: Sat, 2 Mar 2024 04:46:52 +0000 Subject: [PATCH 12/19] Evidence that groupchat not terminating because of the TERMINATE substring. --- test/agentchat/test_groupchat.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 5e7c08349522..f52018a1c2fb 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -662,7 +662,7 @@ def test_graceful_exit_before_max_round(): max_consecutive_auto_reply=10, human_input_mode="NEVER", llm_config=False, - default_auto_reply="This is sam speaking. TERMINATE", + default_auto_reply="This is sam speaking.", ) # This speaker_transitions limits the transition to be only from agent1 to agent2, and from agent2 to agent3 and end. @@ -681,7 +681,7 @@ def test_graceful_exit_before_max_round(): group_chat_manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False, is_termination_msg=None) - agent1.initiate_chat(group_chat_manager, message="'None' is_termination_msg function.") + agent1.initiate_chat(group_chat_manager, message='') # Note that 3 is much lower than 10 (max_round), so the conversation should end before 10 rounds. assert len(groupchat.messages) == 3 @@ -1045,4 +1045,5 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> # test_invalid_allow_repeat_speaker() # test_graceful_exit_before_max_round() # test_clear_agents_history() - test_custom_speaker_selection_with_transition_graph() + #test_custom_speaker_selection_with_transition_graph() + pass From 4bfb0a0493e0d8921e9cb464bede0347012dc2cd Mon Sep 17 00:00:00 2001 From: Joshua Kim Date: Sat, 2 Mar 2024 16:15:36 +1100 Subject: [PATCH 13/19] Raising NoEligibleSpeakerException allows graceful exit before max turns --- test/agentchat/test_groupchat.py | 35 +++++++++++++++++--------------- 1 file changed, 19 insertions(+), 16 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index f52018a1c2fb..265eb0a1b2e2 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -681,7 +681,7 @@ def test_graceful_exit_before_max_round(): group_chat_manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False, is_termination_msg=None) - agent1.initiate_chat(group_chat_manager, message='') + agent1.initiate_chat(group_chat_manager, message="") # Note that 3 is much lower than 10 (max_round), so the conversation should end before 10 rounds. assert len(groupchat.messages) == 3 @@ -972,9 +972,6 @@ def test_custom_speaker_selection_with_transition_graph(): for i in range(26) ] - # Print agents name - # print([agent.name for agent in agents]) - # Initiate allowed speaker transitions allowed_or_disallowed_speaker_transitions = {} @@ -996,14 +993,9 @@ def test_custom_speaker_selection_with_transition_graph(): allowed_or_disallowed_speaker_transitions[previous_agent].append(current_agent) previous_agent = current_agent - # For Kevin to visualize, to remove code - from autogen.graph_utils import visualize_speaker_transitions_dict - - visualize_speaker_transitions_dict(allowed_or_disallowed_speaker_transitions, agents) - def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Agent: - """Define a customized speaker selection function. - A recommended way is to define a transition for each speaker in the groupchat. + """ + Define a customized speaker selection function. """ expected_sequence = ["a", "u", "t", "o", "g", "e", "n"] @@ -1012,7 +1004,12 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> last_speaker_index = expected_sequence.index(last_speaker_char) # Return the next agent in the expected sequence if last_speaker_index == len(expected_sequence) - 1: - return None # ValueError: Custom speaker selection function returned an object of type instead of Agent or str. + # return None # ValueError: Custom speaker selection function returned an object of type instead of Agent or str. + from autogen.agentchat.groupchat import ( + NoEligibleSpeakerException, + ) # TODO: Kevin, we should let the user return None here as NoEligibleSpeakerException is relatively unknown to our users. + + raise NoEligibleSpeakerException("No eligible speaker found in custom_speaker_selection.") else: next_agent = agents[ord(expected_sequence[last_speaker_index + 1]) - 97] return next_agent @@ -1027,8 +1024,14 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> ) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) - agents[0].initiate_chat(manager, message="My name is a") - # TODO: Assert result is a,u,t,o,g,e,n afterwards + results = agents[0].initiate_chat(manager, message="My name is a") + actual_sequence = [] + + # Append to actual_sequence using results.chat_history[idx]['content'][-1] + for idx in range(len(results.chat_history)): + actual_sequence.append(results.chat_history[idx]["content"][-1]) # append the last character of the content + + assert expected_sequence == actual_sequence if __name__ == "__main__": @@ -1045,5 +1048,5 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> # test_invalid_allow_repeat_speaker() # test_graceful_exit_before_max_round() # test_clear_agents_history() - #test_custom_speaker_selection_with_transition_graph() - pass + test_custom_speaker_selection_with_transition_graph() + # pass From 9ac035139595a8398d7e6d66a05ecd22516062b4 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Sat, 2 Mar 2024 11:07:10 -0500 Subject: [PATCH 14/19] update --- .github/workflows/build.yml | 2 +- autogen/agentchat/groupchat.py | 73 ++++++++----------- notebook/agentchat_groupchat_customized.ipynb | 30 +++++++- .../agentchat/test_function_call_groupchat.py | 2 +- test/agentchat/test_groupchat.py | 9 +-- 5 files changed, 65 insertions(+), 51 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index cc9dd400e955..c02e7bc2eccd 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -41,7 +41,7 @@ jobs: python -m pip install --upgrade pip wheel pip install -e . python -c "import autogen" - pip install pytest mock networkx matplotlib + pip install pytest mock - name: Install optional dependencies for code executors # code executors auto skip without deps, so only run for python 3.11 if: matrix.python-version == '3.11' diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index 39f71875b269..07a49f94cb77 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -42,15 +42,18 @@ class GroupChat: - "manual": the next speaker is selected manually by user input. - "random": the next speaker is selected randomly. - "round_robin": the next speaker is selected in a round robin fashion, i.e., iterating in the same order as provided in `agents`. - - a customized speaker selection function: if passed in a function, it will be called with the following parameters: + - a customized speaker selection function (Callable): if passed in a function, it will be called with the following parameters: custom_speaker_selection_func: Parameters: - last_speaker: Agent The last speaker in the group chat. - groupchat: GroupChat The GroupChat object - Returns: - Return an `Agent` class or a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. + Return: + Return one of the following: + 1. an `Agent` class, it must be one of the agents in the group chat. + 2. a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. + 3. None, which indicates the chat should be terminated. - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. @@ -288,8 +291,31 @@ def random_select_speaker(self, agents: Optional[List[Agent]] = None) -> Union[A def _prepare_and_select_agents( self, last_speaker: Agent, - speaker_selection_method: str, ) -> Tuple[Optional[Agent], List[Agent], Optional[List[Dict]]]: + # If self.speaker_selection_method is a callable, call it to get the next speaker. + # If self.speaker_selection_method is a string, return it. + speaker_selection_method = self.speaker_selection_method + if isinstance(self.speaker_selection_method, Callable): + selected_agent = self.speaker_selection_method(last_speaker, self) + if selected_agent is None: + raise NoEligibleSpeakerException( + "Custom speaker selection function returned None. Terminating conversation." + ) + elif isinstance(selected_agent, Agent): + if selected_agent in self.agents: + return selected_agent, self.agents, None + else: + raise ValueError( + f"Custom speaker selection function returned an agent {selected_agent.name} not in the group chat." + ) + elif isinstance(selected_agent, str): + # If returned a string, assume it is a speaker selection method + speaker_selection_method = selected_agent + else: + raise ValueError( + f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." + ) + if speaker_selection_method.lower() not in self._VALID_SPEAKER_SELECTION_METHODS: raise ValueError( f"GroupChat speaker_selection_method is set to '{speaker_selection_method}'. " @@ -396,40 +422,9 @@ def _prepare_and_select_agents( ] return selected_agent, graph_eligible_agents, select_speaker_messages - def _call_custom_speaker_selection_func(self, last_speaker: Agent) -> None: - """ - If self.speaker_selection_method is a function, call it to get the next speaker. - If self.speaker_selection_method is a string, return it. - - Return: - - """ - if isinstance(self.speaker_selection_method, Callable): - selected_agent = self.speaker_selection_method(last_speaker, self) - if isinstance(selected_agent, Agent): - if selected_agent in self.agents: - return selected_agent - else: - raise ValueError( - f"Custom speaker selection function returned an agent {selected_agent.name} not in the group chat." - ) - elif isinstance(selected_agent, str): - # If returned a string, assume it is a speaker selection method - return selected_agent - else: - raise ValueError( - f"Custom speaker selection function returned an object of type {type(selected_agent)} instead of Agent or str." - ) - - return self.speaker_selection_method - def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - temp_selection_method = self._call_custom_speaker_selection_func(last_speaker) - if isinstance(temp_selection_method, Agent): - return temp_selection_method - - selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) if selected_agent: return selected_agent # auto speaker selection @@ -439,11 +434,7 @@ def select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Age async def a_select_speaker(self, last_speaker: Agent, selector: ConversableAgent) -> Agent: """Select the next speaker.""" - temp_selection_method = self._call_custom_speaker_selection_func(last_speaker) - if isinstance(temp_selection_method, Agent): - return temp_selection_method - - selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker, temp_selection_method) + selected_agent, agents, messages = self._prepare_and_select_agents(last_speaker) if selected_agent: return selected_agent # auto speaker selection diff --git a/notebook/agentchat_groupchat_customized.ipynb b/notebook/agentchat_groupchat_customized.ipynb index 2b141c5be04f..08f03e0f5911 100644 --- a/notebook/agentchat_groupchat_customized.ipynb +++ b/notebook/agentchat_groupchat_customized.ipynb @@ -10,7 +10,35 @@ "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", - "In this notebook, we demonstrate how to pass a cumstomized agent selection method to GroupChat.\n", + "In this notebook, we demonstrate how to pass a cumstomized agent selection method to GroupChat. The customized function looks like this:\n", + "\n", + "```python\n", + "def custom_speaker_selection_func(last_speaker, groupchat):\n", + " \"\"\"Define a customized speaker selection function.\n", + " A recommended way is to define a transition for each speaker in the groupchat.\n", + "\n", + " Parameters:\n", + " - last_speaker: Agent\n", + " The last speaker in the group chat.\n", + " - groupchat: GroupChat\n", + " The GroupChat object\n", + " Return:\n", + " Return one of the following:\n", + " 1. an `Agent` class, it must be one of the agents in the group chat.\n", + " 2. a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use.\n", + " 3. None, which indicates the chat should be terminated.\n", + " \"\"\"\n", + " pass\n", + "\n", + "groupchat = autogen.GroupChat(\n", + " speaker_selection_method=custom_speaker_selection_func,\n", + " ...,\n", + ")\n", + "```\n", + "The last speaker and the groupchat object are passed to the function. Commonly used variables from groupchat are `groupchat.messages` an `groupchat.agents`, which is the message history and the agents in the group chat respectively. You can access other attributes of the groupchat, such as `groupchat.allowed_speaker_transitions_dict` for pre-defined allowed_speaker_transitions_dict. \n", + "\n", + "\n", + "\n", "\n", "````{=mdx}\n", ":::info Requirements\n", diff --git a/test/agentchat/test_function_call_groupchat.py b/test/agentchat/test_function_call_groupchat.py index 69b9a569ca83..0217f4cc6276 100755 --- a/test/agentchat/test_function_call_groupchat.py +++ b/test/agentchat/test_function_call_groupchat.py @@ -131,7 +131,7 @@ def test_no_function_map(): ValueError, match="No agent can execute the function get_random_number. Please check the function_map of the agents.", ): - groupchat._prepare_and_select_agents(dummy2, speaker_selection_method="auto") + groupchat._prepare_and_select_agents(dummy2) if __name__ == "__main__": diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 265eb0a1b2e2..83c1330d403d 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -1004,12 +1004,7 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> last_speaker_index = expected_sequence.index(last_speaker_char) # Return the next agent in the expected sequence if last_speaker_index == len(expected_sequence) - 1: - # return None # ValueError: Custom speaker selection function returned an object of type instead of Agent or str. - from autogen.agentchat.groupchat import ( - NoEligibleSpeakerException, - ) # TODO: Kevin, we should let the user return None here as NoEligibleSpeakerException is relatively unknown to our users. - - raise NoEligibleSpeakerException("No eligible speaker found in custom_speaker_selection.") + return None # terminate the conversation else: next_agent = agents[ord(expected_sequence[last_speaker_index + 1]) - 97] return next_agent @@ -1029,7 +1024,7 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> # Append to actual_sequence using results.chat_history[idx]['content'][-1] for idx in range(len(results.chat_history)): - actual_sequence.append(results.chat_history[idx]["content"][-1]) # append the last character of the content + actual_sequence.append(results.chat_history[idx]["content"][-1]) # append the last character of the content assert expected_sequence == actual_sequence From c4ab4a2c24da343a574cee7055490de515caabf0 Mon Sep 17 00:00:00 2001 From: Joshua Kim Date: Sun, 3 Mar 2024 05:46:34 +0000 Subject: [PATCH 15/19] To confirm with author that custom function is meant to override graph constraints --- test/agentchat/test_groupchat.py | 68 ++++++++++++++++++++++++++++++-- 1 file changed, 65 insertions(+), 3 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index 029b7818241e..a9bc521a8ec0 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -1030,7 +1030,7 @@ def test_custom_speaker_selection(): def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Agent: """Define a customized speaker selection function. - A recommended way is to define a transition for each speaker in the groupchat. + A recommended way is to define a transition for each speaker using the groupchat allowed_or_disallowed_speaker_transitions parameter. """ if last_speaker is a1: return a2 @@ -1090,7 +1090,7 @@ def test_custom_speaker_selection_with_transition_graph(): allowed_or_disallowed_speaker_transitions[previous_agent].append(current_agent) previous_agent = current_agent - def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Agent: + def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Optional[Agent]: """ Define a customized speaker selection function. """ @@ -1126,6 +1126,68 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> assert expected_sequence == actual_sequence +def test_custom_speaker_selection_contradicts_transition_graph(): + """ + In this test, team A engineer can transition to team A executor and team B engineer, but team B engineer cannot transition to team A executor. + What should be the expected behavior? + (1) Custom function overrides the constraints of the graph, or + (2) Raise a warning/error? + """ + + # For loop that creates UserProxyAgent with names from a to z + agents = [ + autogen.UserProxyAgent( + name="teamA_engineer", + default_auto_reply="My name is teamA_engineer", + human_input_mode="NEVER", + code_execution_config={}, + ), + autogen.UserProxyAgent( + name="teamA_executor", + default_auto_reply="My name is teamA_executor", + human_input_mode="NEVER", + code_execution_config={}, + ), + autogen.UserProxyAgent( + name="teamB_engineer", + default_auto_reply="My name is teamB_engineer", + human_input_mode="NEVER", + code_execution_config={}, + ), + ] + + allowed_or_disallowed_speaker_transitions = {} + + # teamA_engineer can transition to teamA_executor and teamB_engineer + # teamB_engineer can transition to no one + allowed_or_disallowed_speaker_transitions[agents[0]] = [agents[1], agents[2]] + + def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> Optional[Agent]: + if last_speaker.name == "teamA_engineer": + return agents[2] # Goto teamB_engineer + elif last_speaker.name == "teamB_engineer": + return agents[1] # Goto teamA_executor and contradict the graph + + groupchat = autogen.GroupChat( + agents=agents, + messages=[], + max_round=20, + speaker_selection_method=custom_speaker_selection_func, + allowed_or_disallowed_speaker_transitions=allowed_or_disallowed_speaker_transitions, + speaker_transitions_type="allowed", + ) + manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) + results = agents[0].initiate_chat(manager, message="My name is teamA_engineer") + + # The current approach is (1) Custom function overrides the constraints of the graph. To confirm if this is desired. + print(results.chat_history) + speakers = [] + for idx in range(len(results.chat_history)): + speakers.append(results.chat_history[idx].get("name")) + + assert "teamA_executor" in speakers + + if __name__ == "__main__": # test_func_call_groupchat() # test_broadcast() @@ -1140,5 +1202,5 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> # test_invalid_allow_repeat_speaker() # test_graceful_exit_before_max_round() # test_clear_agents_history() - test_custom_speaker_selection_with_transition_graph() + test_custom_speaker_selection_contradicts_transition_graph() # pass From 3cb43e99b6d266aac67133dcb57061038a8b4c93 Mon Sep 17 00:00:00 2001 From: Joshua Kim Date: Mon, 4 Mar 2024 09:27:20 +0000 Subject: [PATCH 16/19] Confirmed the expected test behaviour with author --- test/agentchat/test_groupchat.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/test/agentchat/test_groupchat.py b/test/agentchat/test_groupchat.py index a9bc521a8ec0..54b8e9f7b1d8 100755 --- a/test/agentchat/test_groupchat.py +++ b/test/agentchat/test_groupchat.py @@ -1126,12 +1126,10 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> assert expected_sequence == actual_sequence -def test_custom_speaker_selection_contradicts_transition_graph(): +def test_custom_speaker_selection_overrides_transition_graph(): """ In this test, team A engineer can transition to team A executor and team B engineer, but team B engineer cannot transition to team A executor. - What should be the expected behavior? - (1) Custom function overrides the constraints of the graph, or - (2) Raise a warning/error? + The expected behaviour is that the custom speaker selection function will override the constraints of the graph. """ # For loop that creates UserProxyAgent with names from a to z @@ -1179,8 +1177,6 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=False) results = agents[0].initiate_chat(manager, message="My name is teamA_engineer") - # The current approach is (1) Custom function overrides the constraints of the graph. To confirm if this is desired. - print(results.chat_history) speakers = [] for idx in range(len(results.chat_history)): speakers.append(results.chat_history[idx].get("name")) @@ -1202,5 +1198,5 @@ def custom_speaker_selection_func(last_speaker: Agent, groupchat: GroupChat) -> # test_invalid_allow_repeat_speaker() # test_graceful_exit_before_max_round() # test_clear_agents_history() - test_custom_speaker_selection_contradicts_transition_graph() + test_custom_speaker_selection_overrides_transition_graph() # pass From a0989374e3d71b35be9daaf711e5453f1bdf620a Mon Sep 17 00:00:00 2001 From: Qingyun Wu Date: Tue, 5 Mar 2024 09:14:19 -0500 Subject: [PATCH 17/19] Update autogen/agentchat/groupchat.py --- autogen/agentchat/groupchat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index a82fce59196e..c99227d93d67 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -53,7 +53,7 @@ class GroupChat: Return one of the following: 1. an `Agent` class, it must be one of the agents in the group chat. 2. a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. - 3. None, which indicates the chat should be terminated. + 3. None, which would terminate the conversation gracefully. - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. From b4dd24d6587c3163987fa0ebfd4fddcf62e761b8 Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Wed, 6 Mar 2024 15:14:34 -0500 Subject: [PATCH 18/19] update --- autogen/agentchat/groupchat.py | 17 +++++++---------- website/docs/Examples.md | 1 + 2 files changed, 8 insertions(+), 10 deletions(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index c99227d93d67..c4319efc5e38 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -42,19 +42,16 @@ class GroupChat: - "manual": the next speaker is selected manually by user input. - "random": the next speaker is selected randomly. - "round_robin": the next speaker is selected in a round robin fashion, i.e., iterating in the same order as provided in `agents`. - - a customized speaker selection function (Callable): if passed in a function, it will be called with the following parameters: - custom_speaker_selection_func: - Parameters: - - last_speaker: Agent - The last speaker in the group chat. - - groupchat: GroupChat - The GroupChat object - Return: - Return one of the following: + - a customized speaker selection function (Callable): the function will be called to select the next speaker. + The function should take the last speaker and the group chat as input and return one of the following: 1. an `Agent` class, it must be one of the agents in the group chat. 2. a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. 3. None, which would terminate the conversation gracefully. - + ```python + def custom_speaker_selection_func( + last_speaker: Agent, groupchat: GroupChat + ) -> Union[Agent, str, None]: + ``` - allow_repeat_speaker: whether to allow the same speaker to speak consecutively. Default is True, in which case all speakers are allowed to speak consecutively. If `allow_repeat_speaker` is a list of Agents, then only those listed agents are allowed to repeat. diff --git a/website/docs/Examples.md b/website/docs/Examples.md index 797f9e4897ab..70cd985c032e 100644 --- a/website/docs/Examples.md +++ b/website/docs/Examples.md @@ -22,6 +22,7 @@ Links to notebook examples: - Automated Task Solving with Coding & Planning Agents - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_planning.ipynb) - Automated Task Solving with transition paths specified in a graph - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_graph_modelling_language_using_select_speaker.ipynb) - Running a group chat as an inner-monolgue via the SocietyOfMindAgent - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_society_of_mind.ipynb) + - Running a group chat with custom speaker selection function - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_groupchat_customized.ipynb) 1. **Sequential Multi-Agent Chats** - Solving Multiple Tasks in a Sequence of Chats Initiated by a Single Agent - [View Notebook](https://github.com/microsoft/autogen/blob/main/notebook/agentchat_multi_task_chats.ipynb) From 3d729b43a1b3ee2c84b4b1e82e3e376b08cb74de Mon Sep 17 00:00:00 2001 From: kevin666aa Date: Wed, 6 Mar 2024 15:14:59 -0500 Subject: [PATCH 19/19] update --- autogen/agentchat/groupchat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/autogen/agentchat/groupchat.py b/autogen/agentchat/groupchat.py index c4319efc5e38..90f19c327a4a 100644 --- a/autogen/agentchat/groupchat.py +++ b/autogen/agentchat/groupchat.py @@ -47,7 +47,7 @@ class GroupChat: 1. an `Agent` class, it must be one of the agents in the group chat. 2. a string from ['auto', 'manual', 'random', 'round_robin'] to select a default method to use. 3. None, which would terminate the conversation gracefully. - ```python + ```python def custom_speaker_selection_func( last_speaker: Agent, groupchat: GroupChat ) -> Union[Agent, str, None]: