Observação: para garantir uma experiência consistente e de alto desempenho, este laboratório pode fornecer respostas armazenadas em cache para algumas solicitações de modelo.

GENAI104

Visão geral

Criar aplicativos agênticos complexos geralmente exige coordenar vários modelos especializados, gerenciar integrações de ferramentas e depurar traces de execução. Tudo isso pode exigir muito trabalho manual e ser difícil de escalonar.

O Kit de Desenvolvimento de Agente (ADK) resolve esses desafios fornecendo um framework modular para criar, testar e implantar sistemas multiagentes. Ele permite compor agentes especializados em uma hierarquia, equipá-los com ferramentas pré-criadas ou personalizadas e orquestrar fluxos de trabalho usando pipelines previsíveis e roteamento dinâmico orientado por LLM.

Neste laboratório, você vai usar o ADK para criar um assistente de pesquisa que usa para analisar dados e gerar relatórios estruturados. Você vai aprender a gerenciar essas dependências de forma dinâmica para garantir que os fluxos de trabalho agênticos permaneçam robustos à medida que novos modelos são lançados.

Objetivos

Neste laboratório, você vai aprender a:

• Descrever a arquitetura de ADK (agentes, ferramentas e sessões).
• Configurar um ambiente de desenvolvimento local para aplicativos agênticos.
• Definir agentes com modelos dinâmicos e acesso a ferramentas personalizadas.
• Usar a interface do navegador do ADK, o código Python e a interface de chat da CLI para executar e inspecionar agentes.

Benefícios do ADK

O ADK oferece vantagens importantes para desenvolvedores criarem aplicativos agênticos:

• Sistemas multiagentes: crie aplicativos modulares e escalonáveis ao compor agentes especializados em estruturas hierárquicas.
• Ecossistema de ferramentas avançado: atribua aos agentes ferramentas pré-criadas, funções personalizadas ou integrações de frameworks como LangChain e CrewAI.
• Orquestração flexível: defina pipelines previsíveis com agentes de fluxo de trabalho ou use LLMs para roteamento adaptativo e dinâmico.
• Experiência integrada do desenvolvedor: desenvolva e depure localmente usando uma CLI avançada e uma interface interativa para inspecionar a execução etapa por etapa.
• Avaliação integrada: analise a qualidade da resposta e as trajetórias de execução com base em casos de teste para avaliar o desempenho sistematicamente.
• Pronto para implantação: faça a conteinerização e o escalonamento de agentes com facilidade no Vertex AI Agent Engine, no Cloud Run ou em uma infraestrutura personalizada do Docker.

Enquanto outros SDKs permitem consultar modelos, o ADK oferece um framework de alto nível que lida com a coordenação complexa entre vários modelos.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. No painel Detalhes do Laboratório, à esquerda, você vai encontrar o seguinte:

   • O botão Abrir Console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer Login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Username"}}}

   Você também encontra o nome de usuário no painel Detalhes do Laboratório.

4. Clique em Próxima.

5. Copie a Senha abaixo e cole na caixa de diálogo de Olá.

   {{{user_0.password | "Password"}}}

   Você também encontra a senha no painel Detalhes do Laboratório.

6. Clique em Próxima.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Tarefa 1: instalar o ADK e configurar o ambiente

Nesta tarefa, você vai configurar o editor do Cloud Shell, inicializar seu projeto e instalar o Kit de Desenvolvimento de Agente (ADK) para preparar o ambiente para criar e testar aplicativos agênticos.

Ativar APIs recomendadas

Neste ambiente de laboratório, a API Vertex AI e a API Telemetry já foram ativadas para você. Nos projetos, é recomendável ativá-las para consultar modelos e enviar dados de telemetria ao Cloud Logging.

Preparar uma guia do editor do Cloud Shell

1. Clique em Ativar o Cloud Shell () na barra de título do console do Google Cloud.

   Observação: como alternativa, selecione a guia do navegador do console e pressione G e S para abrir o terminal do Cloud Shell.

2. Clique em Continuar.

3. Se for preciso autorizar o Cloud Shell, clique em Autorizar.

4. Na barra de ações do terminal do Cloud Shell, clique em Abrir em uma nova janela .

5. Clique em Abrir editor () na barra de ações do editor do Cloud Shell para visualizar os arquivos.

6. Clique em Explorador () no painel à esquerda para abrir o explorador de arquivos.

7. Clique em Abrir pasta.

8. Na caixa de diálogo Abrir pasta, clique em OK para selecionar a pasta inicial da sua conta de estudante do Google Skills.

9. Feche qualquer outro tutorial ou painel do Gemini que apareça no lado direito da tela. Assim você terá mais espaço na janela para o editor de código.

No restante deste laboratório, você vai trabalhar nesta janela como seu ambiente de desenvolvimento integrado (IDE) com o editor e o terminal do Cloud Shell.

Baixar e instalar o ADK e os exemplos de código para este laboratório

1. Cole o comando a seguir no terminal do Cloud Shell para copiar de um bucket do Cloud Storage um diretório de projetos com código para este laboratório:

   gcloud storage cp -r gs://{{{project_0.project_id| YOUR_GCP_PROJECT_ID}}}-bucket/* .

2. Execute os comandos abaixo no terminal do Cloud Shell para atualizar a variável de ambiente PATH, incluir o ambiente local do usuário e instalar o ADK, com o plug-in OpenTelemetry (OTel) para geração de registros e telemetria, além de outros requisitos do laboratório:

   export PATH=$PATH:"/home/${USER}/.local/bin" python3 -m pip install google-adk[otel-gcp]==1.30.0 -r adk_project/requirements.txt

Tarefa 2: analisar os principais conceitos e a estrutura dos diretórios de projetos do ADK

Conheça os principais conceitos e elementos básicos fundamentais do ADK, incluindo agentes, ferramentas e padrões de orquestração, para entender os princípios usados na criação de sistemas multiagentes eficazes e flexíveis:

• Agentes: são elementos básicos criados para realizar tarefas específicas. Eles podem ser alimentados por LLMs para raciocinar, planejar e usar ferramentas, a fim de alcançar objetivos, e até mesmo colaborar em projetos complexos.
• Ferramentas: oferecem aos agentes habilidades além da conversação, permitindo que eles interajam com APIs externas, pesquisem informações, gerem códigos ou chamem outros serviços.
• Serviços de sessão: processam o contexto de uma única conversa (Session), incluindo o histórico (Events) e a memória de trabalho do agente para essa conversa (State).
• Chamadas de retorno: snippets de código personalizados que você fornece para execução em pontos específicos do processo do agente, permitindo verificações, geração de registros ou modificações de comportamento.
• Gerenciamento de artefatos: os artefatos permitem que os agentes salvem, carreguem e gerenciem arquivos ou dados binários (como imagens ou PDFs) associados a uma sessão ou usuário.
• Executor: o mecanismo que gerencia o fluxo da execução, orquestra interações de agentes baseadas em eventos e coordena serviços de back-end.

A seguir, confira o layout padrão de um projeto do ADK para saber como esses conceitos são organizados na prática:

1. No painel do explorador de arquivos do editor do Cloud Shell, clique em adk_project para abrir o diretório.

2. Confira os quatro diretórios de agentes em adk_project: adk_utils, app_agent, llm_auditor e my_google_search_agent. Cada um deles representa um agente separado. Separar os agentes em diretórios próprios dentro de um diretório de projeto ajuda na organização, assim o ADK entende quais agentes estão presentes.

3. Clique em my_google_search_agent para acessar um diretório de agentes.

   Observação: verifique se você está no diretório adk_project/my_google_search_agent.

4. Clique em init.py para visualizar o conteúdo. O diretório também deve ter um arquivo agent.py.

5. O arquivo init.py contém uma única linha, que importa do arquivo agent.py. O ADK usa isto para identificar o diretório como um pacote de agente:

   from . import agent

6. Clique em agent.py para visualizar o código de um agente simples equipado com a ferramenta Pesquisa Google.

   • As importações de google.adk: a classe Agent e a ferramenta google_search do módulo tools.
   • Leia os comentários do código que descrevem os parâmetros que configuram esse agente simples.

7. Para usar a ferramenta google_search importada, ela precisa ser transmitida ao agente. Cole a linha a seguir no arquivo agent.py, próximo à linha 34, no local indicado ao final da criação do objeto Agent:

   tools=[google_search]

8. Salve o arquivo agent.py.

Com as ferramentas, um agente pode realizar ações além de gerar texto. Nesse caso, a ferramenta google_search permite que o agente decida quando precisa de informações além daquelas contidas nos dados de treinamento. Então, ele pode escrever uma consulta de pesquisa, usar a Pesquisa Google para pesquisar na web e fundamentar a resposta ao usuário nos resultados.

Quando um modelo baseia a resposta nas informações que recupera, isso é chamado de "embasamento". Esse processo é conhecido como "geração aumentada por recuperação" ou "RAG".

Tarefa 3: usar a interface de desenvolvimento do ADK para executar o agente

O ADK tem uma interface de desenvolvimento projetada para ser executada localmente e ajudar a desenvolver e testar agentes. Ele ajuda a visualizar o que cada agente está fazendo e como vários agentes interagem entre si. Nesta tarefa, você vai conhecer essa interface.

Observação: ao executar um agente, o ADK precisa saber quem está solicitando as chamadas de API do modelo. Há duas maneiras de fornecer essa informação:

1. Fornecer uma chave de API Gemini.
2. Autenticar o ambiente com credenciais do Google Cloud e associar as chamadas de API do modelo a um projeto e um local da Vertex AI.

Neste laboratório, você vai usar a segunda abordagem para fazer a autenticação com seu projeto da Vertex AI.

1. No terminal do Cloud Shell, execute os comandos abaixo para gravar um arquivo .env e definir as variáveis de ambiente, instruindo o agente a usar seu projeto e o endpoint global:

   cd ~/adk_project cat << EOF > my_google_search_agent/.env GOOGLE_GENAI_USE_VERTEXAI=TRUE GOOGLE_CLOUD_PROJECT={{{project_0.project_id| YOUR_GCP_PROJECT_ID}}} GOOGLE_CLOUD_LOCATION=global MODEL={{{project_0.startup_script.gemini_flash_model_id | gemini_flash_model_id}}} OTEL_SERVICE_NAME=adk-agent OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED=true OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true EOF

   Essas variáveis têm as seguintes funções:

   • GOOGLE_GENAI_USE_VERTEXAI=TRUE indica que você usa a Vertex AI para autenticação em vez da autenticação por chave de API Gemini.
   • GOOGLE_CLOUD_PROJECT e GOOGLE_CLOUD_LOCATION indicam o projeto e o local para associar as chamadas de modelo.
   • MODEL não é obrigatório, mas é armazenado aqui para que possa ser carregado como outra variável de ambiente. Essa pode ser uma maneira conveniente de testar modelos diferentes em ambientes de implantação distintos.
   • OTEL_SERVICE_NAME, OTEL_PYTHON_LOGGING_AUTO_INSTRUMENTATION_ENABLED e OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT são usados para configurar o OpenTelemetry (OTel) para a coleta de dados de telemetria específicos do ADK do agente.

   A interface de desenvolvimento do ADK e a interface de chat da CLI carregam automaticamente as configurações de um arquivo .env. Se nenhum arquivo estiver presente, elas usarão variáveis de ambiente do sistema com nomes correspondentes.

2. No terminal do Cloud Shell, execute o comando abaixo para verificar se você está no diretório adk_project, onde os subdiretórios do agente estão localizados:

   cd ~/adk_project

3. Inicie a interface de desenvolvimento do ADK com o comando a seguir e algumas flags úteis. Esse comando vai:

   • Iniciar um servidor da web do FastAPI com a interface de desenvolvimento do ADK.
   • Permitir que a visualização na web do Cloud Shell consulte seu agente.
   • Enviar dados de telemetria para o Cloud Logging.
   • Recarregar agentes quando mudanças no código forem detectadas.
   adk web \ --allow_origins "regex:https://.*\.cloudshell\.dev" \ --otel_to_cloud \ --reload_agents

   Saída

   INFO: Started server process [2434] INFO: Waiting for application startup. +-------------------------------------------------------+ | ADK Web Server started | | | | For local testing, access at http://localhost:8000. | +-------------------------------------------------------+ INFO: Application startup complete. INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

   O resultado é a exibição do URL da interface de desenvolvimento do ADK, já que ela está em execução.

4. Para visualizar a interface da web em uma nova guia, clique no link http://127.0.0.1:8000 na saída do terminal, que vai conectar você por proxy a esse aplicativo em execução localmente na sua instância do Cloud Shell. O resultado é a execução da interface de desenvolvimento em uma nova guia.

5. Nas opções do menu Selecionar um agente à esquerda, selecione my_google_search_agent.

   

6. Para pedir que o agente use a ferramenta Pesquisa Google, digite a pergunta:

   Sei que os Jogos Olímpicos de Verão acontecerão em 2028. Informe quais países vão participar e quais eventos serão realizados.

   O agente usa a Pesquisa Google para recuperar informações em tempo real, ignorando o limite de conhecimento do modelo pré-treinado.

   Observação: uma resposta que usa embasamento com a Pesquisa Google inclui "sugestões de pesquisa" HTML prontas para exibição, como as que aparecem na parte de baixo da resposta do agente. Ao utilizar o embasamento com a Pesquisa Google, é obrigatório exibir essas sugestões, que ajudam os usuários a acompanhar as informações usadas pelo modelo na resposta.

7. No painel à esquerda, você vê a guia Trace por padrão. Clique no texto da última consulta (Sei que os Jogos Olímpicos de Verão acontecerão em 2028. Informe quais países vão participar e quais eventos serão realizados.) para ver um trace de quanto tempo levou para diferentes partes da consulta serem executadas.

   Use isso para depurar execuções mais complexas que envolvem chamadas de ferramentas e entender como vários processos contribuem para a latência das respostas.

   

8. Volte à seção de discussão do chat da janela e clique no ícone do agente () ao lado da resposta do agente no painel à direita para inspecionar o evento retornado por ele. Esse evento inclui o conteúdo retornado ao usuário e o groundingMetadata que detalha os resultados da pesquisa em que a resposta se baseou.

9. Quando terminar de analisar a interface de desenvolvimento do ADK, feche essa guia do navegador.

10. Volte para a guia do navegador com o terminal do Cloud Shell e clique no painel do terminal.

11. Pressione CTRL+C para interromper o servidor da web.

Clique em Verificar meu progresso para conferir o objetivo. Executar o agente usando a interface da web do ADK.

Tarefa 4: executar um agente de maneira programática

Embora a interface de desenvolvimento do ADK seja ótima para testes e depuração, ela não é adequada para apresentar seu agente a vários usuários em produção.

Para executar um agente como parte de um aplicativo maior, é necessário incluir outros componentes no script agent.py que o app da web processou na tarefa anterior. Siga estas etapas para abrir um script com esses componentes e analisá-los.

1. Você pode definir variáveis de ambiente para todos os seus agentes usarem se não tiverem arquivos .env nos diretórios. No terminal do Cloud Shell, execute os comandos a seguir para exportar variáveis de ambiente:

   export GOOGLE_GENAI_USE_VERTEXAI=TRUE export GOOGLE_CLOUD_PROJECT={{{project_0.project_id| YOUR_GCP_PROJECT_ID}}} export GOOGLE_CLOUD_LOCATION=global export MODEL={{{project_0.startup_script.gemini_flash_model_id | gemini_flash_model_id}}}

2. No navegador de arquivos do editor do Cloud Shell, clique em adk_project/app_agent.

3. Selecione o arquivo agent.py nesse diretório.

4. Esse agente foi projetado para ser executado como parte de um aplicativo. Leia o código comentado em agent.py e confira os seguintes componentes dele:

   • InMemoryRunner() (próximo à linha 68), uma supervisão do recurso de execução do agente: o executor é o código responsável por receber a consulta do usuário, transmiti-la ao agente apropriado, receber o evento de resposta do agente e transmiti-lo de volta ao aplicativo ou à interface de chamada e, por fim, acionar o evento a seguir. Saiba mais na documentação do ADK sobre o loop de eventos.
   • runner.session_service.create_session() (próximo à linha 71), um recurso de histórico de conversas e estado compartilhado. As sessões permitem que um agente preserve o estado, lembrando uma lista de itens, o status atual de uma tarefa ou outras informações "atuais". Essa classe cria um serviço de sessão local para simplificar, mas, na produção, pode ser processada por um banco de dados.
   • types.Content() e types.Part() (próximo às linhas 78 e 79), um recurso de mensagens multimodais estruturadas. Em vez de uma string simples, o agente recebe um objeto de conteúdo que pode consistir em várias partes. Isso permite que mensagens complexas, incluindo conteúdo de texto e multimodal, sejam transmitidas ao agente em uma ordem específica.
   Observação: quando você executou o agente na interface de desenvolvimento do ADK, ele criou um serviço de sessão, um serviço de artefato e um executor. Ao gravar seus próprios agentes para implantação programática, é recomendável fornecer esses componentes como serviços externos, em vez de depender de versões na memória.

   O script inclui uma consulta fixada no código (próxima à linha 93), que pergunta ao agente: "Qual é a capital da França?"

5. Execute o comando a seguir no terminal do Cloud Shell para executar esse agente de maneira programática:

   python3 app_agent/agent.py

   Saída selecionada:

   ** O usuário diz: Qual é a capital da França? ... ** trivia_agent: A capital da França é Paris.

Adicionar classes de esquema Pydantic

Também é possível definir um esquema de entrada e/ou saída específico para um agente da seguinte maneira:

1. Próximo à linha 28, adicione as instruções de importação abaixo para as classes de esquema Pydantic BaseModel e Field para definir uma classe de esquema:

   from pydantic import BaseModel, Field class CountryCapital(BaseModel): capital: str = Field(description="A country's capital.")

2. Na definição de Agent do root_agent, próximo à linha 62, configure o parâmetro output_schema para usar o esquema CountryCapital definido acima:

   output_schema=CountryCapital

3. Execute o script do agente novamente para conferir a resposta seguindo o output_schema:

   python3 app_agent/agent.py

   Saída selecionada:

   ** O usuário diz: Qual é a capital da França? ... ** trivia_agent: {"capital": "Paris"}

Clique em Verificar meu progresso para conferir o objetivo. Executar um agente de maneira programática.

Tarefa 5: conversar com um agente pela interface de linha de comando

Também é possível conversar com um agente no seu ambiente de desenvolvimento local usando a interface de linha de comando. Isso pode ser muito útil para depurar e testar rapidamente os agentes à medida que você os desenvolve.

Assim como a interface da web, a interface de linha de comando também lida com a criação do serviço de sessão, do serviço de artefato e do executor do seu agente.

Para executar uma sessão interativa usando a interface de linha de comando:

1. Execute o seguinte no terminal do Cloud Shell:

   adk run my_google_search_agent

   Saída:

   Log setup complete: /tmp/agents_log/agent.20250322_010300.log To access latest log: tail -F /tmp/agents_log/agent.latest.log Running agent basic_search_agent, type exit to exit. user:

2. Digite a mensagem:

   Quais filmes famosos foram lançados na Índia este ano?

   Exemplo de resposta (pode ser um pouco diferente):

   [google_search_agent]: Aqui estão alguns filmes que foram lançados na Índia no mês passado (janeiro de 2026 a início de fevereiro de 2026): * **16 de janeiro de 2026**: *Bihu Attack*, *Happy Patel: Khatarnak Jasoos*. * **23 de janeiro de 2026**: *Border 2*. * **30 de janeiro de 2026**: *Mardaani 3*, *Mayasabha - The Hall of Illusion*. * **5 de fevereiro de 2026**: *Vadh 2*, *Haunted 3D: Ghosts Of The Past*. * **13 de fevereiro de 2026**: *Tu Yaa Main*, *O'Romeo*, *Swayambhu*,. * **19 de fevereiro de 2026**: *Veer Murarbaji*, *Do Deewane Seher Mein*. * **20 de fevereiro de 2026**: *Epic: Elvis Presley In Concert*, *Hamnet*. * **26 de fevereiro de 2026**: *The Kerala Story 2 Goes Beyond*.

3. Quando terminar de conversar com a interface de linha de comando, digite sair no próximo comando do usuário para encerrar a conversa.

Tarefa 6: visualizar um exemplo de multiagente

Nesta tarefa, você vai conhecer um sistema multiagente para entender um recurso principal do ADK.

Esse sistema agêntico avalia e melhora o embasamento factual das respostas geradas por LLMs. Ele inclui:

• Um critic_agent para funciona como um verificador de fatos automatizado.
• Um reviser_agent para reescrever respostas, se necessário, e corrigir imprecisões com base em descobertas verificadas.

Analise esse agente da seguinte forma:

1. Use o explorador de arquivos do editor do Cloud Shell para acessar o diretório adk_project/llm_auditor.

2. No diretório llm_auditor, clique em agent.py.

3. Confira alguns detalhes sobre este exemplo de multiagente:

   • O SequentialAgent é uma classe de fluxo de trabalho que passa o controle da conversa entre agentes de forma sequencial sem exigir entrada do usuário. Quando executados, o critic_agent e o reviser_agent respondem em ordem automaticamente."
   • Cada um desses subagentes é importado dos próprios diretórios em um diretório sub_agents.
   • Os diretórios de subagentes contêm init.py, agent.py e prompt.py. Use o prompt.py para gerenciar comandos complexos de forma independente antes de importá-los para o agent.py.

4. Copie o arquivo .env criado anteriormente para ser usado também por esse agente. Execute o comando abaixo no terminal do Cloud Shell para iniciar a interface de desenvolvimento do ADK novamente.

   cd ~/adk_project cp my_google_search_agent/.env llm_auditor/.env adk web \ --allow_origins "regex:https://.*\.cloudshell\.dev" \ --otel_to_cloud \ --reload_agents Observação: se você não tiver encerrado a sessão adk web anterior, a porta padrão 8000 será bloqueada, mas você poderá usar adk web --port 8001, por exemplo, para iniciar a interface de desenvolvimento com uma nova porta.

5. Clique no link http://127.0.0.1:8000 na saída do terminal. Uma nova guia do navegador é aberta com a interface de desenvolvimento do ADK.

6. No menu Selecionar um agente à esquerda, selecione llm_auditor.

7. Inicie a conversa com a seguinte informação falsa:

   Double check this: Earth is further away from the Sun than Mars.

Você vai ver duas respostas do agente na área da conversa:

• Primeiro uma resposta detalhada do critic_agent que verifica a veracidade da informação com base na checagem de fatos da Pesquisa Google.
• Depois, uma informação revisada e curta do reviser_agent com uma versão corrigida da sua informação de entrada falsa, por exemplo, "A Terra está mais perto do Sol do que Marte".

8. Ao lado de cada resposta, clique no ícone do agente () para abrir o painel de eventos daquela resposta ou encontre o evento numerado correspondente no painel "Eventos" e o selecione.

Na parte de cima da visualização do evento, há um gráfico que mostra as relações entre os agentes e as ferramentas nesse sistema multiagente. O agente responsável por essa resposta está destacado.

9. Analise o código ou peça outros exemplos de checagem de fatos na interface de desenvolvimento. Outro exemplo que você pode testar é:

   P: Por que o céu é azul? R: Porque ele reflete a cor do oceano.

10. Se você quiser redefinir a conversa, clique em Nova sessão na barra de título da sessão para reiniciar.

11. Quando terminar de fazer perguntas ao agente, feche a guia do navegador e pressione CTRL+C no terminal para interromper o servidor.

Observação: embora esse exemplo use um agente de fluxo de trabalho SequentialAgent, pense nesse padrão como human-in-the-loop.

Quando o SequentialAgent encerra a sequência, a conversa volta ao elemento pai, (nesse exemplo, llm_auditor) para receber uma nova entrada do usuário e retornar a conversa para os outros agentes.

Clique em Verificar meu progresso para conferir o objetivo. Confira um exemplo de multiagente.

Parabéns!

Você concluiu o laboratório básico do Kit de Desenvolvimento de Agente (ADK). Você analisou a arquitetura principal de agentes e ferramentas, inicializou um ambiente de desenvolvimento padronizado e configurou o como uma dependência de modelo dinâmico. Ao implementar ferramentas personalizadas e esquemas de saída estruturados, você controlou o comportamento do agente e executou fluxos de trabalho na interface do navegador, em scripts Python e na CLI. Essas habilidades formam a base para criar e escalonar aplicativos agênticos robustos e prontos para produção.

Próximas etapas / Saiba mais

Para mais informações sobre o ADK, confira estes recursos:

• Documentação do ADK Kit de Desenvolvimento de Agente
• Repositório adk-docs do GitHub adk-docs
• Como proteger os agentes de IA: uma análise técnica detalhada (em inglês)
• Criar um agente multimodal com vários agentes usando o ADK em 37 linhas de código

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 15 de abril de 2026

Laboratório testado em 15 de abril de 2026

Copyright 2026 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.