Course Code: aiengin
Duration: 14 hours
Prerequisites:

Course Summary

This two-day, hands-on workshop trains participants in building multi-agent, LLM-driven applications using AutoGen. Focusing on practical coding labs and real-world problem-solving, it caters to developers or tech-savvy professionals who want to integrate generative AI solutions into their organizations—but do not necessarily code every day.

1.Day 1:

  • Generative AI fundamentals and introduction to AutoGen
  • Hands-on creation of basic multi-agent systems
  • Use case selection (e.g., healthcare triage, financial reporting, etc.

2. Day 2:

  • Advanced AutoGen features (memory modules, concurrency handling)
  • Observability, debugging, and performance tuning (local or via AWS/Azure)

Extended project where learners build a tailored LLM solution and deploy it

Overview:

Key Takeaways & Participant Benefits

1.End-to-End Exposure to Multi-Agent Systems

  • Gain a complete perspective: from defining agent roles to orchestrating tasks and conversations.
  • Understand how to integrate domain-specific logic—whether it’s for regulatory compliance, customer support, or supply chain optimization.

2. Hands-On, Applied Learning

  • Code-first approach with practical labs.
  • Build confidence by tackling real use cases and seeing immediate results.

3. Cloud Integration Skills

  • Learn how to host and scale your AutoGen applications in AWS or Azure.
  • Explore best practices for logging, monitoring, and security compliance in a cloud environment.

4. Improved Efficiency & Innovation

  • Accelerate repetitive tasks (e.g., regulatory reporting) with AI-driven automation.
  • Use time series forecasting for demand planning or production scheduling, boosting operational efficiency.

5. Practical Knowledge for Deployment

  • Learn the crucial elements of deploying AI solutions in real-world contexts—performance tuning, error handling, compliance considerations.
  • Gain familiarity with approaches to version control, containerization, and DevOps practices suitable for LLM-based systems.

6. Adaptable Templates & Frameworks

  • Walk away with sample projects and code structures you can easily repurpose for your own organizational use cases.

By the end of the course, participants will be able to:

  • Conceptualize and implement multi-agent architectures for a variety of industry-specific problems.
  • Harness AutoGen v0.4 to build event-driven, asynchronous AI systems.
  • Integrate cloud resources (AWS or Azure) for data storage, compute, monitoring, and security.
  • Feel confident in deploying generative AI applications that can streamline compliance work, analyze time-series data, and produce intelligent reports or responses in real time.

This practical, end-to-end focus ensures immediate applicability, enabling participants to return to their workplaces ready to develop, optimize, and scale LLM-driven solutions.

Course Outline:

Day 1

Module 1: Generative AI Fundamentals in Practice (1 hour)

  • Conceptual Overview
    • Quick recap of generative AI & large language models (LLMs)
    • Why it matters: Real-world benefits and challenges for developers
  • Practical Demo
    • Live demonstration of a basic text-generation app (e.g., using GPT-like APIs)
    • Brief discussion of prompt engineering fundamentals

Module 2: AutoGen v0.4 – Hands-On Introduction (1.5 hours)

  • Installation & Environment Setup
    • Creating a Python environment for AutoGen (local or in AWS/Azure)
    • Ensuring dependencies are installed correctly
  • Core AutoGen Architecture
    • Event-driven design, layered framework (Core Layer, AgentChat API)
    • Lab Exercise: Spin up a “Hello, World” conversation loop using AutoGen
  • Working with Cloud Resources (optional)
    • If time permits or group interest:
      • Setting up compute resources on AWS (e.g., EC2) or Azure (e.g., Azure VM)
      • Deploying a minimal environment to run AutoGen in the cloud

Module 3: Multi-Agent Applications & Agent Roles (2 hours)

  • Agent Roles and Communications
    • Assistant Agent: Responding to tasks, generating content
    • User Proxy Agent: Simulating users or external services
  • Designing Realistic Agent Flows
    • Coordinating multiple agents to accomplish tasks (e.g., “researcher” + “summarizer”)
    • Asynchronous vs. synchronous messaging styles
  • Live Coding Lab
    • Participants set up a multi-agent application that can:
      1. Accept a user question
      2. Have one agent research or retrieve data (simulated)
      3. Have another agent summarize or respond in plain language
    • Focus on code clarity and minimal scaffolding so participants learn core concepts

Module 4: Quick Win Use Cases (1 hour)

  • Industry Examples
    • Healthcare: Simple triage Q&A agent
    • Finance: Automated Q&A on structured data (e.g., CSV or database)
    • E-Commerce: Product recommendation chatbot
  • Hands-On Adaptations
    • Encourage participants to pick one use case and adapt the multi-agent flow from the previous lab
    • Optional Cloud Integration: Demonstrate how to connect to an external data store (e.g., AWS S3 or Azure Blob Storage) for retrieval tasks

Wrap-Up & Discussion (0.5 hours)

  • Recap of Day 1 key takeaways
  • Open Q&A about challenges encountered during labs

Day 2

Module 5: Advanced AutoGen Techniques (1 hour)

  • Core Layer Deep Dive
    • Event-driven logic patterns
    • Handling parallel requests or concurrency
  • Memory & State Management
    • Using inbuilt memory modules to maintain conversation context
    • Hands-On Demonstration: Letting agents recall previous user queries

Module 6: Observability, Debugging & Performance (1 hour)

  • Monitoring Tools
    • Built-in logging and message tracing
    • Integrating with cloud monitoring services (e.g., Amazon CloudWatch, Azure Monitor)
  • Debugging Techniques
    • Identifying prompt or agent logic issues
    • Adjusting temperature, max tokens, or model parameters for stability
  • Performance Considerations
    • Minimizing latency while maintaining quality
    • Scaling up or down in a cloud environment

Module 7: Extended Hands-On Project (2.5 hours)

  • Project Overview
    • Participants choose an applied scenario to build end-to-end (healthcare, finance, e-commerce, etc.)
    • Define the agent roles, conversation flow, and target outcomes
  • Implementation Steps
    • Data Integration: Connect the application to a (mock or real) data source in the cloud
    • Agent Orchestration: Configure multiple specialized agents (e.g., “Planner,” “Executor,” “Verifier”)
    • User Interface: (Optional) Create a simple CLI or web front-end to interact with the multi-agent system
  • Testing & Iteration
    • Validate agent performance using test prompts
    • Monitor logs in real-time
    • Troubleshoot and optimize

Module 8: Best Practices for Real-World Deployment (1 hour)

  • Design Patterns & Scalability
    • Designing for production usage, handling concurrency
    • Using microservices or containerization (Docker, Kubernetes)
  • Security & Compliance
    • Handling sensitive data (especially in healthcare/finance)
    • Setting up roles and access controls in cloud environments
  • Ethical & Responsible AI
    • Mitigating bias
    • Ensuring user safety and trust

Module 9: Expanded Real-World Use Cases (1 hour)

  • Deep-Dive Industry Examples
    • Healthcare: Automated patient chat & scheduling (HIPAA considerations)
    • Finance: Generating financial reports from large data sets (scalability challenges)
    • Retail: Inventory tracking and intelligent restocking suggestions
    • Manufacturing: Troubleshooting equipment issues using multi-agent “diagnoser” & “fixer” approach
  • Group Brainstorm
    • Discuss potential use cases from participants’ own domains