How you can Construct Agentic Chatbots Utilizing AutoGen?

Introduction

Chatbots have reworked the best way we have interaction with know-how, enabling automated, clever conversations throughout numerous domains. Constructing these chat methods may be difficult, particularly when aiming for flexibility and scalability. AutoGen simplifies this course of by leveraging AI brokers, which deal with advanced dialogues and duties autonomously. On this article, we’ll discover how one can construct agentic chatbots utilizing AutoGen. We’ll discover its highly effective agent-based framework that makes creating adaptive, clever conversational bots simpler than ever.

Overview

• Study what the AutoGen framework is all about and what it could possibly do.
• See how one can create chatbots that may maintain discussions with one another, reply to human queries, search the net, and do much more.
• Know the setup necessities and stipulations wanted for constructing agentic chatbots utilizing AutoGen.
• Discover ways to improve chatbots by integrating instruments like Tavily for net searches.

What’s AutoGen?

In AutoGen, all interactions are modelled as conversations between brokers. This agent-to-agent, chat-based communication streamlines the workflow, making it intuitive to start out constructing chatbots. The framework additionally provides flexibility by supporting numerous dialog patterns reminiscent of sequential chats, group chats, and extra.

Let’s discover the AutoGen chatbot capabilities as we construct several types of chatbots:

1. Dialectic between brokers: Two specialists in a area focus on a subject and attempt to resolve their contradictions.
2. Interview preparation chatbot: We’ll use an agent to organize for the interview by asking questions and evaluating the solutions.
3. Chat with Internet search instrument: We will chat with a search instrument to get any info from the net.

Study Extra: Autogen: Exploring the Fundamentals of a Multi-Agent Framework

On this article, we’re utilizing OpenAI and Groq API keys. Groq provides entry to many open-source LLMs free of charge as much as some charge limits.

We will use any LLM we favor. Begin by producing an API key for the LLM and Tavily search instrument.

Create a .env file to securely retailer this key, preserving it non-public whereas making it simply accessible inside your challenge.

Libraries Required

autogen-agentchat – 0.2.36
tavily-python – 0.5.0
groq – 0.7.0
openai – 1.46.0

Dialectic Between Brokers

Dialectic is a technique of argumentation or reasoning that seeks to discover and resolve contradictions or opposing viewpoints. We let the 2 LLMs take part within the dialectic utilizing AutoGen brokers.

Let’s create our first agent:

from autogen import ConversableAgent

agent_1 = ConversableAgent(
    title="expert_1",
    system_message="""You might be taking part in a Dialectic about considerations of Generative AI with one other knowledgeable. 
                    Make your factors on the thesis concisely.""",
    llm_config={"config_list": [{"model": "gpt-4o-mini", "temperature": 0.5}]},
    code_execution_config=False,
    human_input_mode="NEVER", 
)

Code Clarification

• ConversableAgent: That is the bottom class for constructing customizable brokers that may speak and work together with different brokers, individuals, and instruments to resolve duties.
• System Message: The system_message parameter defines the agent’s position and function within the dialog. On this case, agent_1 is instructed to interact in a dialectic about generative AI, making concise factors on the thesis.
• llm_config: This configuration specifies the language mannequin for use, right here “gpt-4o-mini”. Further parameters like temperature=0.5 are set to regulate the mannequin’s response creativity and variability.
• code_execution_config=False: This means that no code execution capabilities are enabled for the agent.
• human_input_mode=”NEVER”: This setting ensures the agent doesn’t depend on human enter, working fully autonomously.

Now the second agent

agent_2 = ConversableAgent(
    "expert_2",
    system_message="""You might be taking part in a Dialectic about considerations of Generative AI with one other knowledgeable. Make your factors on the anti-thesis concisely.""",
    llm_config={"config_list": [{"api_type": "groq", "model": "llama-3.1-70b-versatile", "temperature": 0.3}]},
    code_execution_config=False, 
    human_input_mode="NEVER",  
)

Right here, we are going to use the Llama 3.1 mannequin from Groq. To know how one can set totally different LLMs, we will refer right here.

Allow us to provoke the chat:

outcome = agent_1.initiate_chat(agent_2, message="""The character of information assortment for coaching AI fashions pose inherent privateness dangers""", 
max_turns=3, silent=False, summary_method="reflection_with_llm")

Code Clarification

On this code, agent_1 initiates a dialog with agent_2 utilizing the offered message.

• max_turns=3: This limits the dialog to 3 exchanges between the brokers earlier than it robotically ends.
• silent=False: It will show the dialog in real-time.
• summary_method=’reflection_with_llm’: This employs a big language mannequin (LLM) to summarize your entire dialogue between the brokers after the dialog concludes, offering a reflective abstract of their interplay.

You’ll be able to undergo your entire dialectic utilizing the chat_history technique.

Right here’s the outcome:

len(outcome.chat_history)
>>> 6
# every agent has 3 replies.

# we will additionally examine the price incurred
print(outcome.price)

# get chathistory
print(outcome.chat_history)

# lastly abstract of the chat
print(outcome.abstract['content'])

Interview Preparation Chatbot

Along with making two brokers chat amongst themselves, we will additionally chat with an AI agent. Let’s do this by constructing an agent that can be utilized for interview preparation.

interviewer = ConversableAgent(
    "interviewer",
    system_message="""You might be interviewing to pick out for the Generative AI intern place. 
    Ask appropriate questions and consider the candidate.""",
    llm_config={"config_list": [{"api_type": "groq", "model": "llama-3.1-70b-versatile", "temperature": 0.0}]},
    code_execution_config=False,
    human_input_mode="NEVER",
    # max_consecutive_auto_reply=2,
    is_termination_msg=lambda msg: "goodbye" in msg["content"].decrease()
)

Code Clarification

Use the system_message to outline the position of the agent.

To terminate the dialog we will use both of the beneath two parameters:

• max_consecutive_auto_reply: This parameter limits the variety of consecutive replies an agent can ship. As soon as the agent reaches this restrict, the dialog robotically ends, stopping it from persevering with indefinitely.
• is_termination_msg: This parameter checks if a message comprises a particular pre-defined key phrase. When this key phrase is detected, the dialog is robotically terminated.

candidate = ConversableAgent(
    "candidate",
    system_message="""You might be attending an interview for the Generative AI intern place. 
    Reply the questions accordingly""",
    llm_config=False,
    code_execution_config=False,
    human_input_mode="ALWAYS",
)

Because the person goes to offer the reply, we are going to use human_input_mode=”ALWAYS” and llm_config=False

Now, we will initialize the mock interview:

outcome = candidate.initiate_chat(interviewer, message="Hello, thanks for calling me.", summary_method="reflection_with_llm")

# we will get the abstract of the dialog too
print(outcome.abstract)

Chat with Internet Search

Now, let’s construct a chatbot that may use the web to seek for the queries requested.

For this, first, outline a perform that searches the net utilizing Tavily.

from tavily import TavilyClient
from autogen import register_function

def web_search(question: str):
    tavily_client = TavilyClient()
    response = tavily_client.search(question, max_results=3)
    return response['results']

An assistant agent which decides to name the instrument or terminate

assistant = ConversableAgent(
    title="Assistant",
    system_message="""You're a useful AI assistant. You'll be able to search net to get the outcomes. 
    Return 'TERMINATE' when the duty is finished.""",
    llm_config={"config_list": [{"model": "gpt-4o-mini"}]},
    silent=True,
)

The person proxy agent is used for interacting with the assistant agent and executes instrument calls.

user_proxy = ConversableAgent(
    title="Consumer",
    llm_config=False,
    is_termination_msg=lambda msg: msg.get("content material") isn't None and "TERMINATE" in msg["content"],
    human_input_mode="TERMINATE",
)

When the termination situation is met, it is going to ask for human enter. We will both proceed to question or finish the chat.

Register the perform for the 2 brokers:

register_function(
    web_search,
    caller=assistant,  # The assistant agent can counsel calls to the calculator.
    executor=user_proxy,  # The person proxy agent can execute the calculator calls.
    title="web_search",  # By default, the perform title is used because the instrument title.
    description="Searches web to get the outcomes a for given question",  # An outline of the instrument.
)

Now we will question:

chat_result = user_proxy.initiate_chat(assistant, message="Who received the Nobel prizes in 2024")

# Relying on the size of the chat historical past we will entry the required content material
print(chat_result.chat_history[5]['content'])

On this approach, we will construct several types of agentic chatbots utilizing AutoGen.

Additionally Learn: Strategic Crew Constructing with AutoGen AI

To grasp AI brokers, checkout our Agentic AI Pioneer Program.

Often Requested Questions

I’m working as an Affiliate Information Scientist at Analytics Vidhya, a platform devoted to constructing the Information Science ecosystem. My pursuits lie within the fields of Pure Language Processing (NLP), Deep Studying, and AI Brokers.