Exploring Microsoft’s AutoGen Framework for Agentic Workflow

Introduction

Within the quickly evolving area of Generative AI, highly effective fashions solely do by means of prompting by people till brokers come, it’s like fashions are brains and brokers are limbs, so, agentic workflow is launched to do duties autonomously utilizing brokers leveraging GenAI mannequin. On this planet of AI improvement brokers are the long run as a result of brokers can do advanced duties with out the direct involvement of people. Microsoft’s AutoGen frameworks stand out as a robust software for creating and managing multi-agent conversations. AutoGen simplifies the method of constructing an AI system that may collaborate, purpose, and remedy advanced issues by means of agent-to-agent interactions.

On this article, we are going to discover the important thing options of AutoGen, the way it works, and how one can leverage its capabilities in initiatives.

Studying Outcomes

• Perceive the idea and performance of AI brokers and their function in autonomous activity execution.
• Discover the options and advantages of the AutoGen framework for multi-agent AI methods.
• Discover ways to implement and handle agent-to-agent interactions utilizing AutoGen.
• Achieve sensible expertise by means of hands-on initiatives involving knowledge evaluation and report era with AutoGen brokers.
• Uncover real-world purposes and use circumstances of AutoGen in numerous domains similar to problem-solving, code era, and training.

This text was printed as part of the Knowledge Science Blogathon.

What’s an Agent?

An agent is an entity that may ship messages, obtain messages and generate responses utilizing GenAI fashions, instruments, human inputs or a mix of all. This abstraction not solely permits brokers to mannequin real-world and summary entities, similar to folks and algorithms. It simplifies the implementation of advanced workflows.

What’s Fascinating in AutoGen Framework?

AutoGen is developed by a group of researchers and engineers. It incorporates the most recent analysis in multi-agent methods and has been utilized in many real-world purposes. AutoGen Framework is extensible and composable which means you may lengthen a easy agent with customizable elements and create workflows that mix these brokers to create a extra highly effective agent. It’s modular and simple to implement.

Brokers of AutoGen

Allow us to now discover brokers of AutoGen.

Conversable Brokers

On the coronary heart of AutoGen are conversable brokers. It’s the agent with base performance and it’s the base class for all different AutoGen brokers. A conversable Agent is able to participating in conversations, processing data, and performing duties.

Brokers Sorts

AutoGen offers a number of pre-defined agent sorts, every designed for particular roles.

• AssistantAgent: A general-purpose AI assistant able to understanding and responding to queries.
• UserProxyAgent: Simulate person habits, permitting for testing and improvement of agent interplay.
• GroupChat: Makes use of a number of brokers to group and they’ll work as a system for doing particular duties.

Dialog Patterns

Patterns allow us to make advanced problem-solving and activity completion by means of collaborating agent interplay.

• one-to-one dialog between brokers
• Group chats with a number of brokers
• Hierarchical dialog the place brokers can delegate duties to sub-agents

How AutoGen Works?

AutoGen facilitates multi-agent dialog and activity execution by means of a complicated orchestration of AI brokers.

Key Course of

Agent Initialization: In AutoGen, we first provoke brokers. These contain creating situations of the agent sorts you want and configuring them with particular parameters.

Instance:

from autogen import AssistantAgent, UserProxyAgent

assistant1 = AssistantAgent("assistant1", llm_config={"mannequin": "gpt-4","api_key":"<YOUR API KEY>"})
assistant2 = AssistantAgent("assistant2", llm_config={"mannequin": "gpt-4","api_key":"<YOUR API KEY>"})

Dialog Move: As soon as the brokers are initialized, AutoGen manages the circulation of dialog between them.

Typical circulation sample:

• A activity or question is launched
• The suitable brokers(s) course of the enter
• Responses are generated and handed to the following brokers or again to the person
• This cycle continues till the duties is accomplished or a termination situation is met.

That is the essential dialog circulation in AutoGen. For working with extra advanced activity processes we are able to mix a number of brokers into a gaggle known as GroupChat, after which use Group Supervisor to handle the dialog. Each group and group supervisor might be chargeable for particular duties.

Process Execution

Because the dialog progresses, brokers could have to carry out particular duties, AutoGen helps numerous activity execution strategies.

• Pure language course of: Brokers can interpret and generate human-like textual content in a number of languages.
• Code Execution: Brokers can create, write, run and debug code in numerous programming languages routinely.
• Exterior API calls: Brokers can work together with exterior companies to fetch or course of knowledge.
• Looking Internet: The agent can routinely search the online similar to Wikipedia to extract data for particular queries.

Error Dealing with and Interplay

AutoGen implements a sturdy error-handling course of. If an agent encounters an error, it could actually typically diagnose and try to repair the difficulty autonomously. This creates a cycle of steady enchancment and problem-solving.

Dialog Termination

Conversations in AutoGen can terminate primarily based on predefined circumstances.

• Process completion
• Reaching a predefined variety of turns
• Express termination command
• Error thresholds

The pliability of this termination situation permits for each fast and focused interplay.

Use Instances and Examples

Allow us to now discover use circumstances and examples of Microsoft’s AutoGen Framework.

Advanced downside fixing

AutoGen excels at breaking down and fixing advanced issues by means of multi-agent collaboration. It may be utilized in scientific analysis to research knowledge, formulate hypotheses, and design experiments.

Code era and Debugging

AutoGen can generate, execute, and debug code throughout numerous programming languages. That is significantly helpful for software program improvement and automation duties.

Automated Promote System

AutoGen framework is nicely suited to multi-agent automated promoting administration. It will probably monitor the shopper’s evaluations, clicks on promoting, automated AB testing on focused promoting, and use GenAI fashions similar to Gemini, and Secure diffusion to generate customer-specific promote 

Schooling Tutoring

AutoGen can create interactive tutoring experiences, the place completely different brokers tackle roles similar to trainer, scholar, and evaluator.

Instance of Trainer-Scholar-Evaluator Mannequin

Allow us to now discover a easy instance of the Trainer-Scholar-Evaluator mannequin.

from autogen import AssistantAgent, UserProxyAgent

trainer = AssistantAgent("Trainer", llm_config={"mannequin": "gpt-4","api_key":"<YOUR API KEY>"})
scholar = UserProxyAgent("Scholar")
evaluator = AssistantAgent("Evaluator", llm_config={"mannequin": "gpt-4","api_key":"<YOUR API KEY>"})

def tutoring_session():
    scholar.initiate_chat(trainer, message="I need assistance understanding quadratic equations.")
    # Trainer explains idea
    scholar.ship(evaluator, "Did I perceive accurately? A quadratic equation is ax^2 + bx + c = 0")
    # Evaluator assesses understanding and offers suggestions
    trainer.ship(scholar, "Let's remedy this equation: x^2 - 5x + 6 = 0")
    # Scholar makes an attempt resolution
    evaluator.ship(trainer, "Assess the scholar's resolution and supply steerage if wanted.")

tutoring_session()

Until now we have now gathered all the mandatory data for working with AutoGen Framework. Now, let’s implement a hands-on mission so we are able to cement our understanding.

Implementing AutoGen in a Mission

On this mission, we are going to use AutoGen Brokers to obtain a dataset from the online and attempt to analyze it utilizing LLM.

Step1: Surroundings Setup

#create a conda surroundings
$ conda create -n autogen python=3.11
# after the creating env
$ conda activate autogen
# set up autogen and mandatory libraries
pip set up numpy pandas matplolib seaborn python-dotenv jupyterlab
pip pyautogen

Now, open your Vscode and begin the mission by making a Jupyter pocket book of your alternative.

Step2: Load Libraries

import os
import autogen
from autogen.coding import LocalCommandLineCodeExecutor
from autogen import ConversableAgent
from dotenv import load_dotenv

Now, accumulate your API keys of the generative mannequin from the respective web site and put them into .env file on the root of the mission. Belew code will load all of the API keys into the system.

load_dotenv()

google_api_key = os.getenv("GOOGLE_API_KEY")
open_api_key = os.getenv("OPENAI_API_KEY")

os.environ["GOOGLE_API_KEY"] = google_api_key.strip('"')
os.environ["OPENAI_API_KEY"] = open_api_key.strip('"')
seed = 42

For GeminiAI, OpenAI

I take advantage of the GeminiAI free model to check the code. Setting the gemini security to NONE.

safety_settings = [
    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
]

Step3: Configuring LLM to Gemini-1.5-flash

llm_config = {
    "config_list": [
        {
            "model": "gemini-1.5-flash",
            "api_key": os.environ["GOOGLE_API_KEY"],
            "api_type": "google",
            "safety_settings": safety_settings,
        }
    ]
}()

Step4: Configuring LLM to OpenAI

llm_config = {
      "config_list" = [{"model": "gpt-4", "api_key": os.getenv("OPENAI_API_KEY")}

}

Step5: Defining Coding Task

coding_task = [
    """download data from https://raw.githubusercontent.com/vega/vega-datasets/main/data/penguins.json""",
    """ find desccriptive statistics of the dataset, plot a chart of their relation between spices and beak length and save the plot to beak_length_depth.png """,
    """Develope a short report using the data from the dataset, save it to a file named penguin_report.md.""",
]

Step5: Designing the Assistant Brokers

I’ll use 4 assistants 

• Person Proxy
• Coder
• Author
• Critic

Person Proxy Agent

It’s an AutoGen Person proxy, it’s a subclass of ConversableAgent, It’s human_input_mode is ALWAYS which suggests it is going to work as a human agent. And its LLM configuration is False. By default, it is going to ask people for enter however right here we are going to put human_input_mode to NEVER, so it is going to work autonomously.

  user_proxy = autogen.UserProxyAgent(
    title="User_proxy",
    system_message="A human admin.",
    code_execution_config={
        "last_n_messages": 3,
        "work_dir": "groupchat",
        "use_docker": False,
    },  # Please set use_docker=True if docker is obtainable to 
        #run the generated code. Utilizing docker is safer than working the generated code instantly.
    human_input_mode="NEVER",
)

Code and Author brokers

To construct Code and Author brokers we are going to leverage AutoGen Assistant Agent which is a subclass of Conversable Agent. It’s designed to unravel duties with LLM. human_input_mode is NEVER. We are able to use a system message immediate with an assistant agent.

coder = autogen.AssistantAgent(
    title="Coder",  # the default assistant agent is able to fixing issues with code
    llm_config=llm_config,
)
author = autogen.AssistantAgent(
    title="author",
    llm_config=llm_config,
    system_message="""
        You're a skilled report author, recognized for
        your insightful and fascinating report for purchasers.
        You rework advanced ideas into compelling narratives.
        Reply "TERMINATE" in the long run when every thing is finished.
        """,
)

Critic Agent

It’s an assistant agent who will maintain the standard of the code created by the coder agent and counsel any enchancment wanted.

system_message="""Critic. You're a useful assistant extremely expert in 
evaluating the standard of a given visualization code by offering a rating 
from 1 (dangerous) - 10 (good) whereas offering clear rationale. YOU MUST CONSIDER 
VISUALIZATION BEST PRACTICES for every analysis. Particularly, you may 
rigorously consider the code throughout the next dimensions
- bugs (bugs):  are there bugs, logic errors, syntax error or typos? Are 
there any the explanation why the code could fail to compile? How ought to or not it's mounted? 
If ANY bug exists, the bug rating MUST be lower than 5.
- Knowledge transformation (transformation): Is the information reworked 
appropriately for the visualization sort? E.g., is the dataset appropriated 
filtered, aggregated, or grouped  if wanted? If a date area is used, is the
 date area first transformed to a date object and many others?
- Aim compliance (compliance): how nicely the code meets the desired 
visualization targets?
- Visualization sort (sort): CONSIDERING BEST PRACTICES, is the 
visualization sort applicable for the information and intent? Is there a 
visualization sort that might be simpler in conveying insights? 
If a special visualization sort is extra applicable, the rating MUST 
BE LESS THAN 5.
- Knowledge encoding (encoding): Is the information encoded appropriately for the 
visualization sort?
- aesthetics (aesthetics): Are the aesthetics of the visualization 
applicable for the visualization sort and the information?

YOU MUST PROVIDE A SCORE for every of the above dimensions.
{bugs: 0, transformation: 0, compliance: 0, sort: 0, encoding: 0, 
aesthetics: 0}
Don't counsel code.
Lastly, primarily based on the critique above, counsel a concrete checklist of actions
 that the coder ought to take to enhance the code.
""",

critic = autogen.AssistantAgent(
    title="Critic",
    system_message = system_message,
    llm_config=llm_config,
    )

Group Chat and Supervisor Creation

In AutoGen we are going to use GroupChat options to group a number of brokers collectively to do particular duties. after which utilizing GroupChatManager to regulate the GroupChat habits.

groupchat_coder = autogen.GroupChat(
    brokers=[user_proxy, coder, critic], messages=[], max_round=10
)

groupchat_writer = autogen.GroupChat(
    brokers=[user_proxy, writer, critic], messages=[], max_round=10
)
manager_1 = autogen.GroupChatManager(
    groupchat=groupchat_coder,
    llm_config=llm_config,
    is_termination_msg=lambda x: x.get("content material", "").discover("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "groupchat",
        "use_docker": False,
    },
)

manager_2 = autogen.GroupChatManager(
    groupchat=groupchat_writer,
    title="Writing_manager",
    llm_config=llm_config,
    is_termination_msg=lambda x: x.get("content material", "").discover("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "groupchat",
        "use_docker": False,
    },
)

Now, we are going to create and person agent to provoke the chat course of and detect the termination command. It’s a easy UserProxy agent acts as a human.

person = autogen.UserProxyAgent(
    title="Person",
    human_input_mode="NEVER",
    is_termination_msg=lambda x: x.get("content material", "").discover("TERMINATE") >= 0,
    code_execution_config={
        "last_n_messages": 1,
        "work_dir": "duties",
        "use_docker": False,
    },  # Please set use_docker=True if docker is obtainable to run the 
      #generated code. Utilizing docker is safer than working the generated 
      #code instantly.
)

person.initiate_chats(
    [
        {"recipient": coder, "message": coding_task[0], "summary_method": "last_msg"},
        {
            "recipient": manager_1,
            "message": coding_task[1],
            "summary_method": "last_msg",
        },
        {"recipient": manager_2, "message": coding_task[2]},
    ]
)

Output

The output of this course of might be very prolonged for brevity I’ll publish a number of the preliminary output.

Right here, you may see the agent will work in steps first obtain the penguin dataset, then begin creating code utilizing coder agent the critic agent will examine the code and counsel enhancements after which it is going to re-run the coder agent to enhance as advised by the critic.

It’s a easy AutoGen agentic workflow, you may experiment with the code and use completely different LLMs.

You will get all of the code used on this article right here

Conclusion

The way forward for AI isn’t just particular person LLMs, however about creating ecosystems of AI entities that may work collectively seamlessly. AutoGen is on the forefront of this paradigm shift, paving the best way for a brand new period of collaborative synthetic intelligence. As you discover AutoGen’s capabilities, bear in mind that you’re not simply working with a software, you’re partnering with an evolving ecosystem of AI brokers. Embrace the probabilities, and experiment with completely different agent configurations and LLMs.

Key Takeaways

• Multi-agent Collaboration: AutoGen simplifies the creation of a multi-agent AI system the place completely different brokers can work collectively to perform a fancy activity.
• Flexibility and Customization: The framework presents in depth customization choices, permitting builders to create brokers tailor-made to particular duties or domains.
• Code Era and Execution: AutoGen brokers can write, debug, and execute code, making it a robust software for software program improvement and knowledge evaluation.
• Conversational Intelligence: By leveraging LLMs brokers can interact in pure language dialog, which makes it appropriate for a variety of purposes from customer support to personalised tutoring.

Steadily Requested Questions

The media proven on this article will not be owned by Analytics Vidhya and is used on the Creator’s discretion.