Master Google ADK - Agent Development Kit (Mac, Win, Ubuntu)

Explore the Google ADK by building a website builder agent with a single prompt. Learn cross-platform setup on Mac, Windows, and Ubuntu, and how to craft a responsive landing page.

Follow along to learn how to build this agent from the provided code, with three setups for macOS, Windows, and Ubuntu.

Learn to set up your development environment by installing python 3.13.4 from python.org, uv, VS Code, and Git across macOS, Windows, and Ubuntu.

Set up python on windows, verify version, install UHV via pip, configure path, install vs code and python extension, then install git, set main as default branch, and verify installations.

Set up Ubuntu by installing python3-pip and python3-venv with apt, install UB via curl, install VS Code with the Python extension, and finish by installing git.

Set up a development and sdk directory, install dependencies from pyproject.toml, configure the Google API key in .env, and run the agent with sdk web to test the website builder.

Set up and run the Google ADK agent on Windows by creating development and sdk folders, a venv, installing dependencies, configuring a Google API key, and launching the server on localhost:8000.

Set up ubuntu by creating the development sdk directories, activate a venv, install dependencies from pyproject.toml, configure the Google API key in .env, and run the agent server at localhost:8000.

Design a professional resume website for a software engineer, generate html, save to an output file, and preview in VS Code across Windows, Mac, and Ubuntu.

Pull the code from the GitHub repo, inspect the version one agent structure, and see how the root agent generates a single HTML file with embedded CSS and JavaScript.

Design a website builder agent from scratch using Google's agent development kit SDK and the Gemini LLM, following four steps: architecture, folder structure, coding, and testing on macOS.

Define the agent architecture using a sequential agent to orchestrate a multi-agent system with requirements writer, designer agent, and code writer agent.

Organize a version two sequential website agent project by setting up folders for agents, outputs, tools, and utils; create init.py, agent.py, description.txt, instructions.txt, and initialize with uv init.

Code the requirements writer agent to convert a web page query into detailed markdown requirements using a sequential language model workflow and load instructions from files for execution.

The designer agent translates the writer agent’s output into a markdown visual design spec detailing the design system, colors, typography, spacing, layout, and components for a single-file html/css/js page.

Learn to build the code writer agent that translates requirements and designer outputs into a single HTML, CSS, and JavaScript file using a file writer tool for deployment.

Create a root website builder agent as a sequential agent that runs the requirements writer agent, designer agent, and code writer agent in order, loading instructions from a file.

Create a .env file with the Google API key, set the google_jni_use_vertex_ai flag to false, and add .env and venv to gitignore before pushing to GitHub.

Test the ADK interface locally, select the Root Website Builder, and iterate design outputs—from requirements to design to HTML, CSS, and JS, validating the agent's responses.

Review the agent development kit website design, highlighting a strong design system, clear content, and sections from header to call to action. Note the ai agents, sdk, and mastery path.

Demonstrates building an ai agent from sequential sub-agents that transform a high-level user query into detailed requirements, a design system, and a single html, css, and js page.

Shows how to build a multi-agent system with Google's agent development kit, integrating a parallel workflow agent into a sequential route website builder to generate a single research web page.

Define a root website builder as a sequential workflow agent that runs subagents in a fixed order: questions generator, questions researcher, query generator, requirements writer, designer, and code writer.

The questions generator agent takes a topic, uses Google Search to research, and outputs exactly five questions for question researcher agent, implemented as an LM agent with Google SDK.

The questions researcher parallel agent runs five specialized LM agents in parallel to research five questions with Google Search and merge results into a single query for the website builder.

The query generator agent synthesizes and merges outputs from five questions researcher agents into a single comprehensive web page requirement generation query, bridging research and requirements writing for website development.

Review the three core agents—questions generator, parallel research agent, and query generator—and trace their handoff to the requirements writer, designer, and code writer to produce a single HTML web page.

Shows how to run a parallel workflow agent with Google ADK, create a virtual environment, install dependencies, and use the SDK web dev UI to generate a web research report.

Launch a cloud deployment of the six-agent sequential pipeline on Google Cloud Run, with a server, API endpoint, Docker container, and HTML report generation.

Open Visual Studio Code and load the A.d.k underscore samples version four deployed to gcloud code, clone or update the SDK underscore samples repository to access it.

Set up a uvicorn driven FastAPI app as the entry point for Google Cloud multi-agent system. Configure sessions, CORS, and web UI for Cloud Run deployment from the agents directory.

Build a containerized multi-agent system for google cloud run with a python 3.13 slim dockerfile, /app as workdir, and requirements.txt; run uvicorn for the fastapi app on 0.0.0.0.

Create a new Google account for a Google Cloud project by signing up, choosing work or business, setting a Gmail address, and completing phone verification and recovery details.

Sign in to Google Cloud, start free with $300 credit, set up a payments profile, and create your first project while reviewing policies and configuring basic organization details.

install the gcloud cli on macOS, verify python 3.x, install python if needed, download the arm64 package, extract, run the installer, initialize, sign in, and select a project.

Create an environment variables file for a Google Cloud project with billing, set the project id and region (us-central1), and configure Gemini 2.5 flash lite via Vertex AI.

Deploy a Google Cloud Run service from source by logging into gcloud, setting environment variables, and allowing unauthenticated access, then obtain the service URL after the build completes.

Demonstrates deploying the ADK agent on Google Cloud Run through the development UI. It generates a research report covering core components, architectural principles, multi-agent system facilitation, and tool integration.

Cleanup deletes website builder agent service in us central one and the artifacts repository to prevent charges. Verify the sdk agent works on Cloud Run's web interface with a query.

Explore the four ways to run a Google ADK agent: the web UI, the API server, a Python runner, and the CLI run, with practical demos.

Run a sequential website agent with three sub agents—requirements writer, designer, and code writer—to generate an html login page with Google sign-in and otp authentication.

Demonstrate the ADK API server workflow by creating a backend endpoint and initializing a user session for an agent. Generate a login page with Google sign-in and phone OTP authentication.

Learn to run an agent programmatically with the ADK runner in Python by configuring the runner, session service, and session context, and processing streamed events to produce a final response.

Set up a virtual environment, install requirements, and run the agent runner. Watch the requirements writer, designer, and code writer produce and save a login page.

Demonstrates the ADK run command line interface by activating the virtual environment and generating a login page with Google sign-in and OTP auth.

Explore testing four methods for the Google ADK agent—SDK web, programmatic Python script, API server, and CLI run—using the provided GitHub code, and choose your preferred approach.

Explore step 1 of building mcp servers for an adk based mcp client using the new streamable http transport, including a stateless server with add, subtract, multiply, and divide tools.

Explore the streamable http transport for MCP servers and clients, load tools from multiple servers, execute combined operations, and save results to results.txt with streaming updates.

Build a universal client with Google's Agent Development Kit and Gemini model that connects to stdio and streamable HTTP servers via a CLI, routing queries to a core MCP agent.

The command.py entry point initializes the MCP client with the app name, user ID, session ID, and tool filter. It runs a chat loop prompting queries and streaming responses.

connects the UI or chat interface to the google sdk agent via the mcp client, managing sessions, loading the agent, routing user input to toolsets, and streaming async responses.

Develop the agent wrapper that loads a Google sdk lm agent to talk to MCP servers over http or stdio, loading tool sets from config.json and applying tool filters.

Explore the MCP config.json for agent development, define server types (http or stdio), endpoints with trailing slash, and commands to run streamable http and stdio servers.

Load environment variables and read a config JSON, implement a simple stdio server with an MCP tool, and set up a virtual environment to run two streamable HTTP servers.

Build an MCP client to connect to a stdio transport server using the model context protocol, upgrading from v1 to v2 with a command-line tutorial and Google agent development kit.

Demonstrate the MCP client workflow by launching the command line interface, connecting to the echo server, and running tool calls to echo text within Google ADK.

Visit the site to download the code or export it to GitHub. Then set up a Gemini API key to iterate with the AI assistant or build MCP server client.

Set up the code by initializing a uv project, creating and activating a virtual environment, installing requirements, configuring the Google API key in the .env file, and running the server.

Review the MCP client manager.py to see how json rpc over stdio enables lifecycle management, tool discovery, and connections to multiple MCP servers with proper shutdown.

LoadConfig reads MCP server configurations from config.json and validates the path. It builds stdio server parameters from command arguments and environment, stores them in server parameters dictionary, and handles exceptions.

Connect to all configured MCP servers by launching server processes, establishing json rpc sessions, and initializing client protocol sessions with automatic cleanup via exit stack.

Aggregate tools from all connected servers by listing tools for each session and compiling them into a single all tools list that the MCP client can access.

CallTool locates a tool by name across server sessions, invokes it with the given arguments, and returns the result; if not on the first server, it checks subsequent sessions.

Learn to gracefully shut down the MCP client by closing the exit stack, triggering exit methods of registered context managers in reverse, closing MCP connections, transports, pipes, and sessions.

Explore a simple echo server built with fast MCP and the MCP tool decorator, showing an echo tool returning text and logs with v1 compatibility.

discover how to integrate Google adk with the mcp toolset to build an llm agent that discovers and uses tools from external servers, loading server config from config.json.

Connect to MCP servers using the Google ADK MCP tool sets to manage connections automatically, then discover tools with toolset.getTools() and display them in a table with names and descriptions.

Initialize the agent development kit agent with the LLM agent class by supplying the name, model, and instructions, and directly pass the mcp toolset to create a ready-to-query brain.

Initialize an in-memory runner that drives the agent loop, taking user input, handling tool calls, executing tools, and returning results to the agent in a continuous query and response cycle.

Start a conversation session with the runner's session service to let the agent remember context across messages, by providing an app name and user ID.

Set up an interactive chat loop in the command line to send user queries to the agent development kit using types.content, process async events, and display the agent response.

Compare the cmd.py command line interface with the MCP client manager, showing how the MCP toolset connects to servers, loads configurations, lists and calls tools, and then shuts down.

Explore advanced tool use on the cloud developer platform, including the tools search tool, programmatic tool calling, and tool use examples, with hands-on Google ADK implementation.

Compare option A and option B for direct tool calling in the Google adk: no-code tool calls via model context and MCP versus code mode with programmatic execution.

Explore programmatic tool calling with Google ADK, where a large language model writes a Python script to orchestrate tool A, tool B, and tool C in a sandbox.

Learn to implement programmatic tool calling with the Google ADK, load add, subtract, multiply, and divide tools from MCP servers, and execute them via a single function call in Python.

Compare programmatic tool calling with direct function calls using the MCP tools, showing how automated tool calls reduce events and API calls to speed up results.

Review the code by running the command line application to send a query, inspect the client and agent implementation, and execute Python code with MCP tools.

Explore no-code agents with Google's agent config, define the agent in YAML, and let the agent development kit translate it into Python for deployment on Google Cloud.

Open the SDK samples in Visual Studio Code, initialize a Python project, create and activate a virtual environment, install Google's SDK, and verify the installation with sdk --version (version 1.14.0).

Create an agent with the ADK by running sdk space create, setting type config and name, selecting a Google AI model, entering API key, and reviewing env, init, and root_agent.yml.

Configure a root agent to route physics and Python questions to specialized tutors, using an LM agent with Gemini 1.5, and implement clear delegation instructions for learning.

Define a root agent with sub agents by listing their configuration files, enabling multi-agent orchestration that delegates Python tutoring or physics tutoring tasks and returns a final response.

Create and configure a physics tutor sub agent that explains laws with real-world examples, solves problems with step-by-step derivations, and uses analogies, inheriting parent model Gemini 1.5 flash unless overridden.

Create and configure a Python tutor agent by writing a Python tutor agent YAML file, pasting the configuration, and running the agent, following the example of the physics tutor agent.

Put together a multi-agent system where the root agent delegates to Python tutor or physics tutor agents, delivering step-by-step explanations for user queries.

Run the agent from the terminal with SDK run in the directory, noting experimental features, and learn to configure with yaml files that delegate to physics or python tutor agents.