Hands-On AI Agents with Google ADK

Build, orchestrate, and deploy production-ready multi-agent systems using Python and Google Cloud

Introduction

1. What This Book Covers
2. Who Should Read This Book
3. How to Use This Book
4. What You Will Be Able to Do After Reading

Chapter 1: Understanding AI Agents

1. What Are AI Agents
2. The Agent Architecture Pattern
3. Why Frameworks Matter for Agents
4. Introducing Google ADK
5. ADK at a Glance

Chapter 2: Getting Started with Google ADK

1. Prerequisites and Environment Setup
2. Installing ADK and Dependencies
3. Getting a Google API Key
4. Your First Agent
5. Adding a Tool
6. Running Agents Locally
7. Project Structure and Organization
8. Common Pitfalls in Setup

Chapter 3: Core ADK Concepts

1. The Agent Class
2. The Runner
3. Sessions and Session Services
4. State Management
5. Events and the Event Loop

Chapter 4: Building with Tools

1. What Are Tools and How Agents Use Them
2. Function Tools
3. Tool Context
4. Built-in Tools
5. Custom Tool Design Patterns
6. Toolsets: Grouping and Dynamic Provisioning
7. Common Pitfalls with Tools

Chapter 5: Memory and Context Management

1. Short-Term vs Long-Term Memory
2. Memory Services
3. Using Memory in Agents
4. Context Caching
5. Context Compression and Compaction
6. Artifacts
7. Common Pitfalls with Memory and Context

Chapter 6: Prompt Engineering for Agents

1. The Instruction Field
2. Referencing Tools in Instructions
3. Handling Tool Return Values
4. Multi-Turn Conversation Design
5. Model Selection and Configuration
6. Common Pitfalls with Instructions

Chapter 7: Workflows and Orchestration

1. Template Workflows
2. Agent Routing
3. Graph-Based Workflows (ADK 2.0)
4. Human-in-the-Loop Patterns
5. Dynamic Workflows
6. Common Pitfalls with Workflows

Chapter 8: Multi-Agent Systems

1. Agent Team Architecture
2. Agents as Tools
3. Collaborative Workflows with Shared State
4. A2A Protocol (Agent-to-Agent)
5. Real-World Multi-Agent Patterns
6. Common Pitfalls with Multi-Agent Systems

Chapter 9: Streaming and Asynchronous Execution

1. Understanding Events
2. Streaming Responses
3. The Event Loop Deep Dive
4. Gemini Live API Toolkit
5. Streaming Tools
6. Common Pitfalls with Streaming

Chapter 10: Retrieval-Augmented Generation (RAG)

1. RAG Fundamentals for Agents
2. Vertex AI Search Integration
3. Building a RAG Tool from Scratch
4. Agentic RAG Patterns
5. Common Pitfalls with RAG

Chapter 11: MCP and External API Integration

1. Model Context Protocol (MCP) Overview
2. Connecting to Existing MCP Servers
3. Building an MCP Server with ADK
4. OpenAPI Tools
5. Authentication for External APIs
6. Common Pitfalls with External Integration

Chapter 12: Structured Outputs and Validation

1. Output Schemas with Pydantic
2. The output_key Parameter
3. Validating LLM Outputs
4. JSON Mode and Structured Function Returns
5. Error Handling Patterns for Structured Data
6. Common Pitfalls with Structured Outputs

Chapter 13: Callbacks and Plugins

1. Callback Types
2. Callback Patterns
3. Plugin Architecture
4. Callbacks vs Plugins: When to Use Each
5. Common Pitfalls with Callbacks and Plugins

Chapter 14: Testing and Evaluation

1. Unit Testing Agent Components
2. Integration Testing with Runners
3. Golden Datasets and Evaluation Frameworks
4. Custom Evaluation Metrics
5. User Simulation Testing
6. Common Pitfalls with Testing

Chapter 15: Observability and Debugging

1. Built-in Logging
2. Distributed Tracing with OpenTelemetry
3. Metrics Collection
4. Third-Party Observability Platforms
5. Debugging Common Issues
6. Common Pitfalls with Observability

Chapter 16: Deployment

1. Deployment Options Compared
2. Deploying to Cloud Run
3. Deploying to GKE
4. Agent Runtime on Google Cloud
5. Environment Configuration
6. Common Pitfalls with Deployment

Chapter 17: Security and Safety

1. Content Safety Filters
2. Guardrails with Callbacks
3. Authentication Patterns
4. Prompt Injection Defense
5. Common Pitfalls with Security

Chapter 18: Production Best Practices

1. Performance Optimization
2. Cost Management
3. Error Handling and Resilience
4. Scaling Patterns
5. Monitoring and Alerting in Production
6. Migration from 1.x to 2.0
7. Common Pitfalls in Production

Conclusion

References