Exploring AutoGen: The Microsoft AI Agentic Framework for Multi-Agent Applications

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from autogen_core import RoutedAgent, DefaultTopicId, TypeSubscription
import asyncio

class ProcessorAgent(RoutedAgent):
    def __init__(self, description: str):
        super().__init__(description)

    async def handle_task(self, message, ctx):
        print(f"Processing task: {message.task_id}")
        await asyncio.sleep(2)  # Simulate work
        print(f"Completed task: {message.task_id}")
        return f"Task {message.task_id} completed"

# Create and register agents
runtime = SingleThreadedAgentRuntime()
agent_one = ProcessorAgent("Agent One")
agent_two = ProcessorAgent("Agent Two")

runtime.register("agent_one", agent_one)
runtime.register("agent_two", agent_two)

# Start runtime and publish messages
runtime.start()
await runtime.publish_message("task_topic", Task(id="001", description="Process data"))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

from autogen_agentchat import ConversableAgent
from openai import AzureOpenAI

# Initialize LLM client
client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_KEY"),
    api_version="2024-02-15-preview"
)

# Define specialized agents
concept_extractor = ConversableAgent(
    name="concept_extractor",
    system_message="""You are a marketing analyst. Given a product description, 
    identify key features, target audience, and unique selling points.""",
    llm_config={"model": "gpt-4", "client": client}
)

copywriter = ConversableAgent(
    name="copywriter",
    system_message="""You are a marketing copywriter. Create compelling 
    marketing copy from the provided analysis.""",
    llm_config={"model": "gpt-4", "client": client}
)

editor = ConversableAgent(
    name="editor",
    system_message="""You are an editor. Improve grammar, clarity, 
    and polish the provided text.""",
    llm_config={"model": "gpt-4", "client": client}
)

# Create workflow
product_description = "Eco-friendly stainless steel water bottle that keeps drinks cold for 24 hours"
result = concept_extractor.initiate_chat(copywriter, message=product_description)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from autogen_agentchat import GroupChat, GroupChatManager

# Define specialized travel agents
planner_agent = ConversableAgent(
    name="planner",
    system_message="""You are a travel planner. Create detailed itineraries 
    with activities, timing, and logistics."""
)

local_agent = ConversableAgent(
    name="local_expert", 
    system_message="""You are a local expert. Suggest authentic local 
    activities, restaurants, and cultural experiences."""
)

language_agent = ConversableAgent(
    name="language_helper",
    system_message="""You are a language assistant. Provide useful phrases 
    and cultural tips for the destination."""
)

summary_agent = ConversableAgent(
    name="summarizer",
    system_message="""Compile all suggestions into a comprehensive travel plan. 
    When complete, respond with TERMINATE."""
)

# Create group chat with round-robin selection
group_chat = GroupChat(
    agents=[planner_agent, local_agent, language_agent, summary_agent],
    messages=[],
    max_round=10,
    speaker_selection_method="round_robin"
)

manager = GroupChatManager(groupchat=group_chat)

# Start planning session
user_proxy.initiate_chat(
    manager, 
    message="Plan a 3-day trip to Auckland, New Zealand"
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from autogen_magentic_one import MagenticOneGroupChat

# Initialize web surfer agent
web_surfer = MagenticOneGroupChat(
    model_client=openai_client,
    task="How full are the Auckland dam levels in April 2025?"
)

# Execute web research
result = await web_surfer.run()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Define development team agents
developer = ConversableAgent(
    name="developer",
    system_message="""You are a senior developer. Write clean, efficient code 
    and provide implementation solutions."""
)

tester = ConversableAgent(
    name="tester", 
    system_message="""You are a QA engineer. Create comprehensive test cases 
    and validate implementations."""
)

tech_lead = ConversableAgent(
    name="tech_lead",
    system_message="""You are a technical lead. Review code, provide feedback, 
    and ensure best practices. Create documentation."""
)

# Task: Convert .NET Web API to Python FastAPI
task = """Convert the .NET 8 Web API project in the current directory 
to a Python FastAPI implementation with equivalent functionality."""

group_chat = GroupChat(agents=[developer, tester, tech_lead])
result = manager.initiate_chat(group_chat, message=task)

1
2
3
4

# Multi-agent customer service system
support_agent = ConversableAgent(name="support", system_message="Handle customer inquiries")
escalation_agent = ConversableAgent(name="escalation", system_message="Handle complex issues")
follow_up_agent = ConversableAgent(name="follow_up", system_message="Ensure customer satisfaction")

1
2
3
4
5

# Automated content creation workflow
researcher = ConversableAgent(name="researcher", system_message="Research topics thoroughly")
writer = ConversableAgent(name="writer", system_message="Create engaging content")
editor = ConversableAgent(name="editor", system_message="Refine and polish content")
seo_optimizer = ConversableAgent(name="seo", system_message="Optimize for search engines")

1
2
3
4
5

# Automated data analysis pipeline  
data_collector = ConversableAgent(name="collector", system_message="Gather and clean data")
analyst = ConversableAgent(name="analyst", system_message="Perform statistical analysis")
visualizer = ConversableAgent(name="visualizer", system_message="Create compelling visualizations")
reporter = ConversableAgent(name="reporter", system_message="Generate executive summaries")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Install AutoGen Agent Chat (recommended for most use cases)
pip install autogen-agentchat

# Install AutoGen Core (for advanced/low-level development)
pip install autogen-core

# Install AutoGen Extensions (for additional capabilities)
pip install autogen-ext

# For all AutoGen components
pip install autogen-agentchat autogen-core autogen-ext

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import os
from autogen_agentchat import ConversableAgent
from openai import AzureOpenAI

# Configure your LLM client
client = AzureOpenAI(
    azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT"),
    api_key=os.getenv("AZURE_OPENAI_KEY"),
    api_version="2024-02-15-preview"
)

# Create your first agent
assistant = ConversableAgent(
    name="assistant",
    system_message="You are a helpful AI assistant.",
    llm_config={"model": "gpt-4", "client": client}
)