Fingers-on Information to Constructing Multi Agent Chatbots with Autogen

Chatbots have developed from easy question-answer methods to classy, clever brokers able to dealing with advanced conversations. As interactions in numerous fields turn into extra nuanced, the demand for chatbots that may seamlessly handle a number of contributors and complicated workflows grows. Due to frameworks like AutoGen, creating dynamic multi-agent environments is now extra accessible. In our earlier article, we mentioned constructing a two-agent chatbot utilizing AutoGen. Nevertheless, there’s a rising want for capabilities past the usual two-person chat. Utilizing AutoGen, we are able to implement conversion patterns like sequential and nested chat. These functionalities create fluid, multi-participant exchanges that may deal with advanced workflows and dynamic interactions. On this article, we’ll discover how AutoGen facilitates these superior dialog patterns and talk about their sensible functions.

What are Multi-Agent Chatbots?

Multi-agent chatbots are AI methods the place a number of specialised brokers work collectively to finish duties or handle advanced conversations. Every agent focuses on a selected function, similar to answering questions, offering suggestions, or analyzing knowledge. This division of experience permits the chatbot system to reply extra precisely and effectively. By coordinating with a number of brokers, the chatbot can ship extra versatile and in-depth responses in comparison with a single-agent system.

Multi-agent chatbots are perfect for advanced environments like customer support, e-commerce, and training. Every agent can tackle a distinct operate, similar to dealing with returns, making product ideas, or aiding with studying supplies. When carried out proper, multi-agent chatbots present a smoother, quicker, and extra tailor-made consumer expertise.

What are Dialog Patterns in Autogen?

To coordinate multi-agent conversations, AutoGen has the next dialog patterns that contain greater than two brokers.

1. Sequential Chat: This entails a sequence of conversations between two brokers, every linked to the following. A carryover mechanism brings a abstract of the prior chat into the context of the next one.
2. Group Chat: It is a single dialog that features greater than two brokers. A key consideration is deciding which agent ought to reply subsequent, and AutoGen affords a number of methods to prepare agent interactions to suit numerous situations.
3. Nested Chat: Nested chat entails packaging a workflow right into a single agent, permitting it to be reused inside a bigger workflow.

On this weblog, we’ll discover ways to implement Sequential Chat.

What’s Sequential Chat?

In a sequential dialog sample, an agent begins a two-agent chat, after which the chat abstract is carried ahead to the following two-agent chat. On this means, the dialog follows a sequence of two-agent chats.

As proven within the above picture, the dialog begins with a chat between Agent A and Agent B with the given context and message. Then, a abstract of this chat is offered to the opposite two-agent chats because the carryover.

On this picture, Agent A is widespread amongst all of the chats. However, we are able to additionally use completely different brokers in every two-agent chat.

Now, why do we’d like this, as a substitute of a easy two-agent chat? This sort of dialog is beneficial the place a job could be damaged down into inter-dependent sub-tasks and completely different brokers can higher deal with every sub-task.

Pre-requisites

Earlier than constructing AutoGen brokers, guarantee you will have the mandatory API keys for LLMs. We will even use Tavily to go looking the net.

Load the .env file with the API keys wanted.

Outline the LLM for use as a config_list

config_list = {

	"config_list": [{"model": "gpt-4o-mini", "temperature": 0.2}]

}

Key Libraries Required

autogen-agentchat – 0.2.37

Implementation

Let’s see how a sequential chat utilizing a number of brokers could be constructed on Autogen. On this instance, we’ll create a inventory evaluation agentic system. The system will be capable to get inventory costs of shares, get current information associated to them, and write an article on the shares. We’ll use  Nvidia and Apple for example, however you should utilize it for different shares as effectively.

Outline the Duties

financial_tasks = [

	"""What are the current stock prices of NVDA and AAPL, and how is the performance over the past month in terms of percentage change?""",

	"""Investigate possible reasons for the stock performance leveraging market news.""",

]

writing_tasks = ["""Develop an engaging blog post using any information provided."""]

Outline the Brokers

We’ll outline two assistants for every of the monetary duties and one other assistant for writing the article.

import autogen

financial_assistant = autogen.AssistantAgent(
	identify="Financial_assistant",
	llm_config=config_list,
)
research_assistant = autogen.AssistantAgent(
	identify="Researcher",
	llm_config=config_list,
)
author = autogen.AssistantAgent(
	identify="author",
	llm_config=config_list,
	system_message="""
    	You're a skilled author, identified for
    	your insightful and interesting articles.
    	You remodel advanced ideas into compelling narratives.
    	Reply "TERMINATE" in the long run when all the things is finished.
    	""",
)

Since getting the inventory knowledge and information wants an online search, we’ll outline an agent able to code execution.

user_proxy_auto = autogen.UserProxyAgent(
	identify="User_Proxy_Auto",
	human_input_mode="ALWAYS",
	is_termination_msg=lambda x: x.get("content material", "") and x.get("content material", "").rstrip().endswith("TERMINATE"),
	code_execution_config={
    	"work_dir": "duties",
    	"use_docker": False,
	})

We’ll use human_input_mode as “ALWAYS”, in order that we are able to test the code generated and ask the agent to make any modifications if vital.

The generated code is saved within the ‘duties’ folder.

We are able to additionally use Docker to execute the code for security.

Financial_assistant and research_assistant will generate the code vital and ship it to user_proxy_auto for execution.

Since ‘author’ doesn’t must generate any code, we’ll outline one other consumer agent to talk with ‘author’.

user_proxy = autogen.UserProxyAgent(
	identify="User_Proxy",
	human_input_mode="ALWAYS",
	is_termination_msg=lambda x: x.get("content material", "") and x.get("content material", "").rstrip().endswith("TERMINATE"),
	code_execution_config=False)

Right here additionally, we’ll use human_input_mode as ‘ALWAYS’ to supply any suggestions to the agent.

Pattern Dialog

Now, we are able to begin the dialog.

chat_results = autogen.initiate_chats(
	[
    	{
        	"sender": user_proxy_auto,
        	"recipient": financial_assistant,
        	"message": financial_tasks[0],
        	"clear_history": True,
        	"silent": False,
        	"summary_method": "last_msg",
    	},
    	{
        	"sender": user_proxy_auto,
        	"recipient": research_assistant,
        	"message": financial_tasks[1],
        	"summary_method": "reflection_with_llm",
    	},
    	{
        	"sender": user_proxy,
        	"recipient": author,
        	"message": writing_tasks[0]
    	},
	])

As outlined above, the primary two-agent chat is between user_proxy_auto and financial_assistant, the second chat is between user_proxy_auto and research_assistant, and the third is between user_proxy and author.

The preliminary output shall be as proven on this picture

In case you are glad with the outcomes by every of the brokers sort exit within the human enter, else give helpful suggestions to the brokers.

Chat Outcomes

Now let’s get the chat_results. We are able to entry the outcomes of every agent.

len(chat_results)
>> 3  # for every agent

We see that we’ve got 3 outcomes for every of the brokers. To get the output of chat for a selected agent we are able to use applicable indexing. Right here is the response we bought from the final agent, which is a author agent.

As you’ll be able to see above, our author agent has communicated with the Monetary Assistant and Analysis Assistant brokers, to present us a complete evaluation of the efficiency of NVIDIA and Apple shares.

Conclusion

AutoGen’s dialog patterns, like sequential, enable us to construct advanced, multi-agent interactions past normal two-person chats. These patterns allow seamless job coordination, breaking down advanced workflows into manageable steps dealt with by specialised brokers. With AutoGen, functions throughout finance, content material era, and buyer help can profit from enhanced collaboration amongst brokers. This allows us to create adaptive, environment friendly conversational options tailor-made to particular wants.

If you wish to be taught extra about AI Brokers, checkout our unique Agentic AI Pioneer Program!

Often Requested Questions