AG2 Practical Exercises

This document contains hands-on exercises designed to reinforce the concepts covered in the AG2 course. Each exercise builds upon previous knowledge and provides practical experience with different aspects of the framework.

Exercise 1: Your First AG2 Agent

Objective: Create a basic conversable agent and understand fundamental concepts.

Instructions:

1. Set up your development environment with AG2 installed
2. Create a simple conversable agent that can answer questions about a specific topic
3. Test the agent with various questions
4. Experiment with different system messages and observe behavior changes

Starter Code:

from autogen import ConversableAgent, LLMConfig

# TODO: Configure your LLM
llm_config = LLMConfig(api_type="openai", model="gpt-4o-mini")

with llm_config:
    # TODO: Create your agent with an appropriate system message
    agent = ConversableAgent(
        name="your_agent",
        system_message="Your system message here",
    )

# TODO: Test your agent
# agent.generate_reply(messages=[{"role": "user", "content": "Your question here"}])

Expected Outcome: A working agent that can respond to questions in character.

---

Exercise 2: Human-in-the-Loop Decision Making

Objective: Implement a workflow that requires human approval for certain actions.

Instructions:

1. Create an agent that can make recommendations
2. Implement human approval for high-impact decisions
3. Test both automatic approval and human intervention scenarios
4. Add error handling for invalid human input

Starter Code:

from autogen import ConversableAgent, UserProxyAgent, LLMConfig

llm_config = LLMConfig(api_type="openai", model="gpt-4o-mini")

with llm_config:
    # TODO: Create a recommendation agent
    recommender = ConversableAgent(
        name="recommender",
        system_message="You make recommendations and ask for approval when needed.",
    )

# TODO: Create a human proxy agent
human_proxy = UserProxyAgent(
    name="human_proxy",
    human_input_mode="TERMINATE",  # Modify as needed
    code_execution_config={"work_dir": "temp", "use_docker": False}
)

# TODO: Implement the approval workflow

Expected Outcome: A system that can operate autonomously but seeks human approval for important decisions.

---

Exercise 3: Multi-Agent Collaboration

Objective: Build a team of agents that work together to solve a complex problem.

Instructions:

1. Create at least 3 specialized agents (e.g., researcher, analyst, writer)
2. Implement a GroupChat to coordinate their collaboration
3. Define clear roles and responsibilities for each agent
4. Test the system with a complex task that requires all agents

Starter Code:

from autogen import ConversableAgent, GroupChat, GroupChatManager, LLMConfig

llm_config = LLMConfig(api_type="openai", model="gpt-4o-mini")

with llm_config:
    # TODO: Create specialized agents
    agent1 = ConversableAgent(
        name="agent1",
        system_message="Your role description",
        description="Brief description for group chat"
    )
    
    # TODO: Add more agents
    
    # TODO: Create coordinator agent with termination condition
    coordinator = ConversableAgent(
        name="coordinator",
        system_message="Coordinate the team and decide when task is complete",
        is_termination_msg=lambda x: "COMPLETE" in (x.get("content", "") or "").upper(),
    )

# TODO: Set up GroupChat and GroupChatManager
# TODO: Initiate collaboration on a complex task

Expected Outcome: A functioning team of agents that can collaborate effectively on multi-step tasks.

---

Exercise 4: Tool Integration

Objective: Create agents that can use external tools to enhance their capabilities.

Instructions:

1. Define at least 2 custom tools (functions) that agents can use
2. Register these tools with appropriate agents
3. Create a workflow where agents use tools to solve problems
4. Implement proper error handling for tool failures

Starter Code:

from typing import Annotated
from autogen import ConversableAgent, register_function, LLMConfig

# TODO: Define your custom tools
def your_tool(parameter: Annotated[str, "Parameter description"]) -> str:
    """Tool description for the agent."""
    # TODO: Implement your tool logic
    return "Tool result"

llm_config = LLMConfig(api_type="openai", model="gpt-4o-mini")

with llm_config:
    # TODO: Create tool-using agent
    tool_agent = ConversableAgent(
        name="tool_agent",
        system_message="You can use tools to solve problems.",
    )

# TODO: Create executor agent
executor = ConversableAgent(
    name="executor",
    human_input_mode="NEVER",
)

# TODO: Register your tools
register_function(
    your_tool,
    caller=tool_agent,
    executor=executor,
    description="Tool description"
)

# TODO: Test tool usage

Expected Outcome: Agents that can effectively use external tools to solve problems they couldn't handle with LLM capabilities alone.

---

Exercise 5: Customer Support System

Objective: Build a complete customer support automation system.

Instructions:

1. Create agents for different support functions (triage, technical, billing)
2. Implement routing logic based on customer inquiry type
3. Add escalation procedures for complex issues
4. Include quality assurance and follow-up mechanisms

Requirements:

• Handle at least 3 different types of customer inquiries
• Implement proper escalation to human agents when needed
• Maintain conversation context throughout the support process
• Generate summary reports of support interactions

Expected Outcome: A working customer support system that can handle common inquiries automatically while escalating complex issues appropriately.

---

Exercise 6: Research Assistant

Objective: Create a research assistant that can gather, analyze, and synthesize information.

Instructions:

1. Build agents for information gathering, analysis, and report writing
2. Implement fact-checking and validation processes
3. Create structured output formats for research results
4. Add capabilities for handling multiple research topics simultaneously

Requirements:

• Gather information from multiple sources (simulated)
• Perform analysis and identify key insights
• Generate well-structured research reports
• Include citations and source validation

Expected Outcome: A research assistant system that can conduct comprehensive research and produce high-quality reports.

---

Exercise 7: Creative Content Generation

Objective: Build a creative team that can generate and refine content collaboratively.

Instructions:

1. Create agents for ideation, writing, editing, and review
2. Implement iterative refinement processes
3. Add style and quality guidelines
4. Include feedback incorporation mechanisms

Requirements:

• Generate creative content ideas
• Produce initial drafts based on ideas
• Implement editing and refinement cycles
• Ensure final output meets quality standards

Expected Outcome: A creative content generation system that can produce high-quality content through collaborative agent interaction.

---

Exercise 8: Production Deployment

Objective: Deploy an AG2 application in a production-like environment.

Instructions:

1. Choose one of your previous exercises to deploy
2. Implement proper logging and monitoring
3. Add error handling and recovery mechanisms
4. Create deployment documentation and procedures

Requirements:

• Containerize your application
• Implement health checks and monitoring
• Add configuration management
• Include backup and recovery procedures
• Document deployment and operational procedures

Expected Outcome: A production-ready AG2 application with proper operational support.

---

Capstone Project: Multi-Agent Business Application

Objective: Create a comprehensive business application using AG2 that demonstrates mastery of all course concepts.

Project Options:

1. E-commerce Management System: Order processing, inventory management, customer service
2. Content Marketing Platform: Content planning, creation, review, and publication
3. Project Management Assistant: Task planning, resource allocation, progress tracking
4. Educational Platform: Course creation, student assessment, personalized learning

Requirements:

• Use at least 5 different agents with specialized roles
• Implement human-in-the-loop workflows where appropriate
• Include tool integration for external services
• Add comprehensive error handling and recovery
• Implement monitoring and logging
• Create user documentation and deployment guides
• Include testing and quality assurance procedures

Deliverables:

1. Complete working application
2. Architecture documentation
3. User manual
4. Deployment guide
5. Testing documentation
6. Presentation of your solution

Evaluation Criteria:

• Functionality and completeness
• Code quality and organization
• Documentation quality
• Innovation and creativity
• Practical utility and usability

---

Additional Practice Challenges

Challenge 1: Agent Personality Development

Create agents with distinct personalities that affect their communication style and decision-making patterns.

Challenge 2: Dynamic Agent Creation

Build a system that can create new agents dynamically based on changing requirements.

Challenge 3: Multi-Language Support

Implement agents that can communicate in multiple languages and translate between them.

Challenge 4: Performance Optimization

Optimize an existing multi-agent system for better performance and resource utilization.

Challenge 5: Security Implementation

Add comprehensive security features to protect sensitive data and prevent unauthorized access.

---

Submission Guidelines

For each exercise:

1. Submit complete, working code
2. Include a README with setup and usage instructions
3. Provide test cases and example outputs
4. Document any assumptions or limitations
5. Include a brief reflection on what you learned

Getting Help

• Review the course materials and examples
• Check the official AG2 documentation
• Join the AG2 Discord community for support
• Participate in study groups and peer discussions

Assessment Rubric

Excellent (90-100%):

• Code works perfectly and handles edge cases
• Clean, well-documented, and maintainable code
• Creative solutions that go beyond basic requirements
• Comprehensive testing and error handling

Good (80-89%):

• Code works correctly for most scenarios
• Generally well-structured with adequate documentation
• Meets all basic requirements
• Some testing and error handling

Satisfactory (70-79%):

• Code works for basic scenarios
• Meets minimum requirements
• Basic documentation provided
• Limited testing

Needs Improvement (Below 70%):

• Code has significant issues or doesn't work
• Missing key requirements
• Poor documentation or structure
• No testing or error handling

Remember: The goal is to learn and practice. Don't hesitate to experiment, make mistakes, and iterate on your solutions!