Exploring Microsoft’s AutoGen Framework for Agentic Workflow

Introduction

Within the quickly evolving area of Generative AI, highly effective fashions solely do via 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 the earth of AI growth brokers are the longer term as a result of brokers can do complicated duties with out the direct involvement of people. Microsoft’s AutoGen frameworks stand out as a strong instrument for creating and managing multi-agent conversations. AutoGen simplifies the method of constructing an AI system that may collaborate, cause, and remedy complicated issues via 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 position in autonomous process execution.
• Discover the options and advantages of the AutoGen framework for multi-agent AI methods.
• Learn to implement and handle agent-to-agent interactions utilizing AutoGen.
• Achieve sensible expertise via hands-on initiatives involving information evaluation and report era with AutoGen brokers.
• Uncover real-world functions and use instances of AutoGen in numerous domains akin to problem-solving, code era, and schooling.

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, akin to individuals and algorithms. It simplifies the implementation of complicated workflows.

What’s Attention-grabbing in AutoGen Framework?

AutoGen is developed by a neighborhood of researchers and engineers. It incorporates the most recent analysis in multi-agent methods and has been utilized in many real-world functions. AutoGen Framework is extensible and composable that means you may prolong a easy agent with customizable elements and create workflows that mix these brokers to create a extra highly effective agent. It’s modular and straightforward 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 info, and performing duties.

Brokers Sorts

AutoGen supplies a number of pre-defined agent varieties, 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 growth 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 complicated problem-solving and process completion via 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 process execution via a classy orchestration of AI brokers.

Key Course of

Agent Initialization: In AutoGen, we first provoke brokers. These contain creating cases of the agent varieties 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 Circulation: As soon as the brokers are initialized, AutoGen manages the movement of dialog between them.

Typical movement sample:

• A process 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 fundamental dialog movement in AutoGen. For working with extra complicated process processes we will mix a number of brokers into a bunch known as GroupChat, after which use Group Supervisor to handle the dialog. Each group and group supervisor shall be chargeable for particular duties.

Job Execution

Because the dialog progresses, brokers might must carry out particular duties, AutoGen helps numerous process 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 robotically.
• Exterior API calls: Brokers can work together with exterior providers to fetch or course of information.
• Looking out Internet: The agent can robotically search the net akin to Wikipedia to extract info for particular queries.

Error Dealing with and Interplay

AutoGen implements a strong error-handling course of. If an agent encounters an error, it may usually diagnose and try to repair the problem autonomously. This creates a cycle of steady enchancment and problem-solving.

Dialog Termination

Conversations in AutoGen can terminate primarily based on predefined situations.

• Job completion
• Reaching a predefined variety of turns
• Specific 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 instances and examples of Microsoft’s AutoGen Framework.

Complicated drawback fixing

AutoGen excels at breaking down and fixing complicated issues via multi-agent collaboration. It may be utilized in scientific analysis to research information, formulate hypotheses, and design experiments.

Code era and Debugging

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

Automated Promote System

AutoGen framework is nicely suited to multi-agent automated promoting administration. It might probably observe the client’s opinions, clicks on promoting, automated AB testing on focused promoting, and use GenAI fashions akin to Gemini, and Steady diffusion to generate customer-specific promote 

Schooling Tutoring

AutoGen can create interactive tutoring experiences, the place completely different brokers tackle roles akin to instructor, pupil, and evaluator.

Instance of Instructor-Scholar-Evaluator Mannequin

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

from autogen import AssistantAgent, UserProxyAgent

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

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

tutoring_session()

Until now we’ve gathered all the required data for working with AutoGen Framework. Now, let’s implement a hands-on undertaking so we will cement our understanding.

Implementing AutoGen in a Undertaking

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

Step1: Surroundings Setup

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

Now, open your Vscode and begin the undertaking 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, gather your API keys of the generative mannequin from the respective web site and put them into .env file on the root of the undertaking. 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 exploit 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 

• Consumer Proxy
• Coder
• Author
• Critic

Consumer Proxy Agent

It’s an AutoGen Consumer proxy, it’s a subclass of ConversableAgent, It’s human_input_mode is ALWAYS which suggests it should work as a human agent. And its LLM configuration is False. By default, it should ask people for enter however right here we are going to put human_input_mode to NEVER, so it should 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 out there to 
        #run the generated code. Utilizing docker is safer than operating the generated code immediately.
    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 will 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, identified for
        your insightful and interesting report for purchasers.
        You remodel complicated ideas into compelling narratives.
        Reply "TERMINATE" in the long run when every thing is finished.
        """,
)

Critic Agent

It’s an assistant agent who will care for the standard of the code created by the coder agent and recommend 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 
fastidiously consider the code throughout the next dimensions
- bugs (bugs):  are there bugs, logic errors, syntax error or typos? Are 
there any explanation why the code might fail to compile? How ought to it's fastened? 
If ANY bug exists, the bug rating MUST be lower than 5.
- Knowledge transformation (transformation): Is the information remodeled 
appropriately for the visualization kind? 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 so forth?
- Aim compliance (compliance): how nicely the code meets the required 
visualization objectives?
- Visualization kind (kind): CONSIDERING BEST PRACTICES, is the 
visualization kind applicable for the information and intent? Is there a 
visualization kind that may be more practical in conveying insights? 
If a unique visualization kind is extra applicable, the rating MUST 
BE LESS THAN 5.
- Knowledge encoding (encoding): Is the information encoded appropriately for the 
visualization kind?
- aesthetics (aesthetics): Are the aesthetics of the visualization 
applicable for the visualization kind and the information?

YOU MUST PROVIDE A SCORE for every of the above dimensions.
{bugs: 0, transformation: 0, compliance: 0, kind: 0, encoding: 0, 
aesthetics: 0}
Don't recommend code.
Lastly, primarily based on the critique above, recommend a concrete listing 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="Consumer",
    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 out there to run the 
      #generated code. Utilizing docker is safer than operating the generated 
      #code immediately.
)

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 shall be very prolonged for brevity I’ll put up among 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 verify the code and recommend enhancements after which it should re-run the coder agent to enhance as urged 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 way in which 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 instrument, you might be partnering with an evolving ecosystem of AI brokers. Embrace the chances, 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 posh process.
• Flexibility and Customization: The framework gives 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 strong instrument for software program growth and information evaluation.
• Conversational Intelligence: By leveraging LLMs brokers can have interaction in pure language dialog, which makes it appropriate for a variety of functions from customer support to customized tutoring.

Steadily Requested Questions

The media proven on this article just isn’t owned by Analytics Vidhya and is used on the Creator’s discretion.