Generative AI in Practice Part 2

Northeastern University via Coursera

Go to class Write review

Overview

Google, IBM & Meta Certificates – 40% Off

One Coursera Plus subscription covers most Professional Certificates on Coursera.

Unlock All Certificates

Welcome to Generative AI in Practice! This course provides an engaging exploration into the transformative world of generative AI and its applications in engineering problem-solving. The course offers a hands-on, application-focused approach to understanding and leveraging generative AI tools to address real-world challenges. This course emphasizes practical applications of generative AI across various domains, with special emphasis on how these technologies can be leveraged to solve complex engineering problems.

Syllabus

Multi-Agent Systems (CrewAI)
- In this module, you'll move beyond single agents to multi-agent systems—teams of specialized AI agents that work together to solve problems no single agent could tackle alone. A single agent has one context window, one persona, and one set of instructions; ask it to research and write and edit, and quality degrades quickly. Specialization fixes that. You'll learn the core building blocks of CrewAI—agents, tasks, and crews—and explore the three patterns that power most production systems: sequential pipelines, hierarchical management, and peer review. Through two labs, you'll build a research-and-writing crew from scratch, then scale up to a four-agent system with task dependencies, delegation, and hierarchical orchestration. By the end, you'll know when to reach for multi-agent architectures and how to design crews that are more reliable, scalable, and maintainable than any single agent could be.
Frontend for AI
- In this module, you'll close the gap between "it works in my notebook" and "anyone can use it"—a transition where many AI projects fail to reach real users. Building a working AI pipeline isn't enough if no one outside your terminal can run it. You'll learn the two dominant tools for putting AI in front of real users: Gradio, which turns any Python function into a shareable web demo in just a few lines, and Streamlit, which builds full interactive dashboards with charts, filters, and session state. Through two labs, you'll build Gradio apps (text analyzer, chatbot, image classifier) and a Streamlit dashboard with AI-powered natural language queries. By the end, you'll know when to reach for each tool, how to deploy your work to the web for free, and how to secure your apps for real users.
Vision, Multimodal, and Evaluation
- AI systems are increasingly capable of processing more than text—they can analyze images, interpret diagrams, and reason across multiple input types simultaneously. In this module, you'll explore how multimodal AI works, how to interact with vision APIs programmatically, and why evaluation is one of the most underinvested parts of building with LLMs. You'll build a hands-on vision pipeline, implement automated evaluation metrics, and examine how real companies are deploying vision AI at scale across healthcare, manufacturing, and finance.
Claude Code and Agent SDKs
- In this module, you'll see how agent development changed. For most of the course, building an agent meant choosing a framework, writing glue code, and stitching components together by hand. In 2026, the model providers ship their own SDKs, and much of that scaffolding disappears. You'll start with the shift itself: why first-party SDKs like the Claude Agent SDK and Google's ADK now handle the tool use, memory, and orchestration that used to be your job. Then you'll build with both, first an agent that reads files, searches the web, and writes structured reports, then a multi-agent research pipeline. From there you'll meet Claude Code, the agentic coding tool this entire course was built with, and use it to rebuild the Module 4 Beer Game as a smarter multi-agent system with its own dashboard. Finally, you'll compare all five agent-building options you now know, framework and SDK alike, so you can choose the right tool for a job instead of defaulting to the one you learned first.
AI Platforms — Google A2A & OpenAI Agents SDK
- In this module, you'll move from building single agents to connecting them. Earlier you sent a prompt and got an answer, then you gave models tools and memory to make agents, and in Module 11 you connected an agent to your tools and data with MCP. The next step is coordination: getting multiple specialized agents to work together, which is where platforms come in. You'll study two answers to that problem. Google's A2A protocol is an open standard that lets agents built by different teams, in different frameworks, discover each other and exchange work through Agent Cards and Tasks. The OpenAI Agents SDK is a lightweight toolkit for assembling one working multi-agent app from four primitives: Agents, Tools, Handoffs, and Guardrails. Across two labs you'll build with the SDK, wiring a triage agent that routes requests to specialists with safety checks at the edges. By the end, you'll be able to tell MCP, A2A, and an agent SDK apart, and know which to reach for when.
AI Ethics, Safety, and Guardrails
- In this module, you'll build AI that is fast and careful at the same time. Everything you've built so far assumes cooperative users and trustworthy data. Production systems get neither, and when an LLM application breaks, what breaks can be a person's career, health, or trust. You'll work through the three layers of LLM risk that map onto the OWASP Top 10: the attacks that come in (prompt injection, both direct and indirect, plus jailbreaks), the ways output goes wrong (hallucination, PII leakage, toxic content), and the bias that accumulates quietly across the whole lifecycle. Then you'll turn defense into engineering, building input, output, and system guardrails that chain together so that even when one check fails, the next one catches it. Finally, you'll move from the how to the why: the responsible AI principles and external frameworks (NIST AI RMF, the EU AI Act) that regulators and enterprise buyers will hold your system to, distilled into a checklist you can run before anything ships.
Putting It All Together
- This is where everything converges. There are no new techniques to learn in this module, only the work of putting what you already know together into something real. Across the course you moved from your first API call through prompt engineering, structured output, RAG, agents, multi-agent systems, MCP, and guardrails. Your final project asks you to choose a genuine problem and build a working AI system that solves it, combining at least three of those techniques into an architecture that holds together. You'll work solo or in a team of up to three, starting from a one-page proposal, then building a functional demo, presenting it live, and documenting your architecture and decisions in a technical report backed by a clean, reproducible codebase. The goal is not the most complex system but the most convincing one: a problem worth solving, an approach that fits it, and an honest account of what works and what still doesn't. This is the piece you'll show people when they ask what you can build.