AI Fundamentals
Build the parts of a docs assistant: model requests, context, structured output, document ranking, validated tool calls and evaluations.
Courses
Each course teaches one part of an AI application in order, with runnable code and tests. Free, with no account required.
17 courses · 221 lessons
All courses
Model Context Protocol (MCP)
Implement, test and secure MCP servers and clients, from stdio to a remote OAuth-protected service with scoped database access.
Building Agents with Google ADK 2.0
Build agents, tools and multi-step workflows with Google ADK 2.0, then evaluate them.
Connecting Agents to Tools and Services with Google ADK 2.0
Connect agents to BigQuery, databases through MCP Toolbox, Agent Search, Google Search and code execution, then add Skills and A2A.
Running and Deploying Agents with Google ADK 2.0
Serve, observe, evaluate and deploy ADK agents with runtime controls, context caching, traces, simulated users, Cloud Run and Agent Runtime.
Building Live and Voice Agents with Google ADK 2.0
Stream audio and screen frames with ADK live agents, handle tools and sessions, test voice callbacks, and build a custom WebSocket bridge.
Building Agents with LangGraph
Build and compare self-contained code-review agents and workflows with LangGraph: tools, stop conditions, context and token budgets, timeouts, checkpoints, idempotent retries, verified outcomes, human approval and memory.
Retrieval-Augmented Generation (RAG)
Build developer-document search with LangChain and pgvector, then answer from retrieved text and charts with checked source references.
Building Agentic RAG Applications
Build a document-retrieval application with ingestion, hybrid search, context budgets, bounded search/read policies, FastAPI and MCP interfaces, and local evaluation and release controls.
LLM Evals
Test LLM features with pytest and DeepEval, measure RAG and tool-call quality per stage, and gate prompt, model and dataset changes on regressions in CI.
Building, Evaluating, and Deploying Agents with Google Agents CLI
Scaffold, enhance, upgrade, evaluate, deploy, publish and observe ADK agents across the full Google Agents CLI lifecycle.
Building AI Systems
Choose, measure and improve an AI system against explicit quality, latency, cost and failure requirements.
Building MLOps
Build reproducible data and model artifacts, serve a selected classifier, and exercise local release and monitoring controls.
Build a Small Language Model From Scratch
Build and inspect a small one-block transformer and its complete local training and generation path.
Agent Design, Optimization and Harnesses
Choose a control policy, improve it on separated task data and independently verify bounded local actions.
Context and Memory Engineering for AI Agents
Assemble bounded model requests, compare context policies and maintain scoped memory with explicit provenance, retention and deletion rules.
LLM Inference Engineering
Implement and inspect inference request handling, cache ownership, scheduling, measurement and capacity decisions using real local runs and clearly bounded experiments.
All lessons
- Run inference with a local LLM
- Count tokens with the model's tokenizer
- Trace next-token generation
- Send chat messages within the context window
- Control sampling, output limits and streaming
- Call a local model and a hosted API
- Get structured output and validate it with Pydantic
- Rank documents with embeddings
- Validate a model-proposed tool call
- Defend a tool-using assistant against prompt injection
- Write your first eval for an LLM app
- Implement an MCP server with typed tool contracts
- Serve MCP over stdio and Streamable HTTP, and test the contracts
- Build an MCP client with discovery, calls and tracing
- Expose resources and prompts from an MCP server
- Integrate MCP tools into ADK and LangGraph agents
- Secure a remote MCP server with OAuth 2.1 and scoped tokens
- Build a read-only database MCP server with scoped roles
- Build your first ADK agent with Gemini
- Run an agent and read its event stream
- Give an agent typed function tools
- Connect an agent to MCP servers with McpToolset
- Persist session state and long-term memory
- Guard model and tool calls with callbacks and plugins
- Build a graph workflow from nodes and edges
- Route a workflow with conditional edges
- Pause a workflow for human approval
- Build dynamic workflows in Python
- Delegate to sub-agents through a coordinator
- Evaluate an agent's tool trajectory and response
- Choose an ADK workflow pattern
- Generate and review
- Iterative refinement
- Parallel fan-out and gather
- Hierarchical task decomposition
- Give an agent skills from a folder with SkillToolset
- Use Gemini built-in tools: Google Search grounding and code execution
- Query PostgreSQL through MCP Toolbox for Databases
- Query BigQuery with BigQueryToolset
- Search private data stores with Agent Search
- Expose the docs assistant over A2A and consume it
- Serve an agent over HTTP and drive it from the CLI
- Configure an ADK Agent with YAML
- Tune a run with RunConfig and read the event loop
- Resume an interrupted agent run
- Rewind a session and migrate its database
- Run an agent from event triggers
- Keep long sessions in budget with compaction and context caching
- Save and load files with Artifacts
- Call a REST API from an OpenAPI spec, with authentication
- Make tools parallel-ready
- Expose the docs assistant as an MCP server
- Trace and measure agent runs with OpenTelemetry
- Test an agent against simulated users
- Inject tool failures with environment simulation
- Write a custom eval metric and optimize the instruction
- Apply safety and security guardrails to agent tools
- Use Agent Platform models, sessions and Memory Bank
- Scaffold and deploy an agent with the Agents CLI
- Deploy an ADK agent to Agent Runtime
- Deploy an ADK agent to Cloud Run
- Stream a voice conversation with run_live
- Read live events and manage live sessions
- Send audio, images and video, and configure voice
- Call tools during a live conversation
- Run live agents inside a workflow
- Guard and evaluate a voice agent
- Build a custom WebSocket server for a live agent
- Build a graph agent with tools
- Add branches and stop conditions to a LangGraph agent
- Trim conversation history to a token budget in LangGraph
- Add timeouts and token budgets to a LangGraph agent
- Checkpoint a LangGraph workflow and resume it after a crash
- Make LangGraph retries idempotent
- Plan, execute and verify a multi-step task in LangGraph
- Add human-in-the-loop interrupts
- Add a long-term memory store
- Build an embedding pipeline with LangChain
- Build a PostgreSQL vector store with LangChain
- Compare exact, HNSW and IVFFlat search in pgvector
- Build a RAG pipeline with citations
- Build multimodal RAG with chart source references
- Inspect cosine distance under the hood
- How RAG works
- Build a RAG pipeline
- Build a RAG eval dataset
- Record a RAG baseline
- Load developer documentation
- Track passage sources
- Handle ingestion failures
- Version documents and chunks
- Resume document ingestion
- Update and delete indexed content
- How BM25 ranks documents
- Add vector retrieval
- Apply filters across retrievers
- Build hybrid retrieval
- Rerank retrieved passages
- Compare retrieval configurations
- Choose chunk boundaries
- Retrieve surrounding context
- Assemble context within a token budget
- Stream RAG answers
- Handle conflicting documentation
- Add search and read tools
- Refine queries with a scripted policy
- Bound scripted retrieval runs
- Compare fixed, scripted and Gemini retrieval policies
- Serve the RAG application with FastAPI
- Build a retrieval inspector
- Connect retrieval tools through MCP
- Authorize collection searches
- Cache retrieval results
- Trace RAG requests
- Limit concurrent RAG requests
- Run RAG evals on an updated corpus
- Evaluate scripted retrieval tasks
- Release the RAG application
- Build the developer knowledge assistant
- Build an eval harness with pytest
- Measure RAG and tool-call quality
- Write robustness tests for an LLM app
- Gate releases on eval regressions in CI
- Check evaluation datasets for leakage
- Bind an eval run to a release manifest
- Scaffold, lint, and run an ADK project with Google Agents CLI
- Enhance, upgrade, and extend an Agents CLI project
- Generate traces and grade evaluations with agents-cli eval
- Synthesize user simulations and compare evaluation runs
- Provision Terraform infrastructure and deploy with agents-cli
- Publish to Gemini and configure agent observability
- Choose an architecture from task requirements
- Create an evaluation set and a failure taxonomy
- Set task acceptance criteria and request resource budgets
- Define a task-specific answer rubric using the existing eval runner
- Separate source support, action correctness and format validity
- Measure quality by request slice and asymmetric failure cost
- Build a repeated-trial benchmark that records failures and incomplete runs
- Build a paired comparison report with uncertainty and slice-level results
- Build a portable model adapter with contract tests
- Build a model selection harness
- Build authentication and authorization boundaries for users and tools
- Build a policy boundary for untrusted notes, tool outputs, and agent handoffs
- Build a guardrails proxy with streaming-output tests
- Build end-to-end request tracing with source provenance
- Build LLM monitoring for latency, cost and errors
- Profile KV-cache work across serving workloads
- Compare full updates and low-rank adaptation
- Compare packed weight quantization and output error
- Admit decoding requests between token steps
- Inspect a direct preference optimization update
- Run group-relative policy updates on sampled completions
- Train a baseline model
- Measure the cost of prediction errors
- Choose evaluation splits
- Handle late data and delayed labels
- Validate incoming data
- Build historical feature snapshots
- Check features before serving
- Version the data and feature contract
- Capture the training configuration
- Record and select a training run
- Export a full-precision inference bundle
- Gate a model candidate on validation results
- Register and select a content-addressed model
- Serve a versioned predictor through batch and HTTP
- Shadow predictions without changing live responses
- Route a sticky canary and compare cohort outcomes
- Roll back a model with feature-contract checks
- Distinguish schema, freshness and distribution signals
- Join delayed outcomes and review retraining
- Build one training step by hand
- Build a byte-pair encoding tokenizer
- Build a next-token prediction baseline
- Build causal self-attention and inspect intermediate outputs
- Build a transformer block with positional information
- Build a small language-model training pipeline
- Build checkpoints and resumable training
- Build text generation with sampling controls
- Build a KV cache for LLM generation
- Build a local server for the trained model
- Compare a handwritten transformer with PyTorch
- Compare a workflow with a bounded policy
- Run a search-and-read decision loop
- Delegate independent tasks with explicit worker state
- Curate traces before selecting an improvement
- Tune retrieval policy on separated task families
- Calibrate task graders before comparing policies
- Bound a local repair process
- Build a coding-agent loop
- Verify edits independently of completion claims
- Build a context assembler for instructions, history, tools, and retrieved passages
- Build context compaction with information-loss tests
- Build isolated contexts for users, tasks, and agents
- Build a context-selection benchmark
- Build a memory service with explicit user and task scope
- Build memory provenance and deletion
- Build working, semantic, and episodic memory retrieval
- Build memory consolidation with conflict tests
- Build a 50-turn memory-compaction benchmark with fact-retention checks
- Build a memory usefulness eval
- Trace a real inference request from prompt to first token
- Stream model output and stop work when the client disconnects
- Benchmark streaming inference under load
- Budget model weights, KV cache, and runtime memory
- Choose hardware from the workload bottleneck
- Implement paged cache allocation and copy-on-write
- Explain tiled attention and verify its output
- Schedule requests between decode iterations
- Balance long-prompt prefill against streaming latency
- Reuse prompt prefixes without overloading a warm replica
- Quantize a model and evaluate the regression
- Check speculative decoding correctness and its cost
- Choose a latency-throughput operating point
- Investigate host overhead before changing GPU settings
- Compare eager and compiled normalization on real tensors
- Investigate inference tail latency with request records
- Protect interactive requests from noisy neighbors
- Plan cold starts and gate model rollouts
- Budget cache transfer before splitting inference pools
- Size serving capacity from accepted benchmark results
Learning path
Courses in a suggested order for one role.
Learning path
AI Agent Engineer
Choose a bounded workflow or agent, connect tools and retrieval, evaluate its behavior, then build a developer knowledge assistant.
- AI Fundamentals
- Building AI Systems
- Building Agents with Google ADK 2.0 or Building Agents with LangGraph
- Model Context Protocol (MCP)
- Retrieval-Augmented Generation (RAG)
- LLM Evals
- Agent Design, Optimization and Harnesses
- Building Agentic RAG Applications