GSP1350

Visão geral

Esse laboratório tem como foco a implementação e a implantação de um serviço de agente cliente com o Kit de Desenvolvimento de Agente (ADK, na sigla em inglês) para criar um agente de IA que usa ferramentas remotas, como um servidor do Protocolo de Contexto de Modelo (MCP, na sigla em inglês). O princípio arquitetônico central desse laboratório é a separação de responsabilidades: a camada de raciocínio (o agente) comunica-se com a camada de ferramentas (o servidor MCP) por uma API segura.

Nesse laboratório, um servidor MCP pré-implantado fornece aos LLMs dados sobre os animais de um zoológico fictício. Você vai criar um aplicativo Python que será um agente de guia turístico do zoológico fictício. O agente usa o servidor MCP para ter acesso a informações sobre os animais do zoológico e usa a Wikipédia para criar a melhor experiência de turismo possível.

Por fim, você vai implantar o agente de guia turístico no Google Cloud Run para que a execução não seja apenas local, e todos os visitantes do zoológico possam acessá-lo.

O que você vai aprender

Neste laboratório, você aprenderá a:

• Estruturar um projeto Python para implantação do ADK.
• Implementar um agente que vai usar ferramentas com o google-adk.
• Conectar um agente a um servidor MCP remoto para ter acesso ao conjunto de ferramentas dele.
• Implantar um aplicativo Python como um contêiner sem servidor no Cloud Run.
• Configurar a autenticação segura entre serviços usando papéis do IAM.
• Excluir recursos do Cloud para evitar custos futuros.

Por que implantar no Cloud Run?

O Cloud Run é uma ótima opção para hospedar agentes do ADK porque é uma plataforma sem servidor. Isso permite que você se concentre no código, não no gerenciamento da infraestrutura. O Cloud Run cuida do trabalho operacional para você.

Pense nele como uma loja pop-up, que só abre e usa recursos quando há clientes (no caso, solicitações). Se nenhum cliente aparece, ela fica fechada e você não precisa pagar para manter uma loja vazia.

Principais recursos do Cloud Run

Executa contêineres em qualquer lugar

• É possível usar contêineres (imagens Docker) que contêm seu app.
• O Cloud Run executa todos na infraestrutura do Google.
• Sem a dor de cabeça de lidar com patches do SO, fazer escalonamentos ou configurar VMs.

Escalonamento automático

• Se nenhuma pessoa estiver usando seu app → nenhuma instância será executada (você não paga nada quando o app está inativo).
• Se o serviço receber 1.000 solicitações, ele vai gerar quantas cópias forem necessárias.

Sem estado por padrão

• Cada solicitação pode ser encaminhada a uma instância diferente.
• Caso você precise armazenar o estado, use um serviço externo como Cloud SQL, Firestore ou Redis.

Funciona com qualquer linguagem ou framework

• Contanto que seja executado em um contêiner Linux, o Cloud Run não se importa se você usa Python, Go, Node.js, Java ou .Net.

Pague pelo que usar

• Cobrança por solicitação + tempo de computação (até 100 ms).
• Você não paga por recursos inativos como em uma VM tradicional.

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.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

2. Clique nas seguintes janelas:

   • Continue na janela de informações do Cloud Shell.
   • Autorize o Cloud Shell a usar suas credenciais para fazer chamadas de APIs do Google Cloud.

Depois de se conectar, você verá que sua conta já está autenticada e que o projeto está configurado com seu Project_ID, . A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

3. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

4. Clique em Autorizar.

Saída:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Observação: consulte a documentação completa da gcloud no Google Cloud no guia de visão geral da gcloud CLI.

Tarefa 1: baixar e instalar o ADK e criar uma pasta de projeto

Nessa tarefa, você vai ativar as APIs relevantes e criar uma pasta de projeto para armazenar o código-fonte da implantação do seu projeto Python.

Ativar as APIs e definir as variáveis de ambiente

1. No Cloud Shell, clique em Abrir editorpara que o editor do Cloud Shell seja aberto no seu diretório principal.
2. Na barra de ações do editor do Cloud Shell, clique em Visualizar > Terminal.

Observação: talvez seja necessário aumentar a altura da janela do navegador para acessar a opção "Visualizar" no menu.

Use essa janela como seu ambiente de desenvolvimento integrado com o editor do Cloud Shell (acima) e o terminal do Cloud Shell (abaixo) ao longo de todo o laboratório.

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

3. No terminal, insira este comando para configurar o projeto:

   gcloud config set project {{{project_0.project_id | filled in at lab start}}}

Saída esperada: você vai receber uma mensagem de saída confirmando a propriedade atualizada.

Observação: caso o Cloud Shell atinja o tempo limite ou seja reiniciado, você terá que configurar o projeto outra vez.

4. Execute este comando para ativar todos os serviços necessários:

   gcloud services enable \ run.googleapis.com \ artifactregistry.googleapis.com \ cloudbuild.googleapis.com \ aiplatform.googleapis.com \ compute.googleapis.com

Saída esperada: você vai receber uma mensagem de saída confirmando que a operação foi concluída.

Clique em Verificar meu progresso para conferir o objetivo. Ativar as APIs

Criar os diretórios do projeto

1. Execute o comando abaixo, que cria uma pasta principal no laboratório para o código-fonte do agente:

   mkdir zoo_guide_agent && cd zoo_guide_agent

Agora já é possível criar o arquivo requirements.txt. Ele lista as bibliotecas Python necessárias para o agente do zoológico.

2. Execute o comando a seguir para criar o arquivo no diretório zoo_guide_agent e abrir no editor do Cloud Shell para fazer edições nele:

   cloudshell edit requirements.txt

3. Adicione o texto abaixo ao arquivo requirements.txt e pressione CTRL+S para salvar as alterações:

   google-adk==1.28.0 langchain==1.2.14 langchain-community==0.4.1 wikipedia

4. Execute o comando a seguir no terminal para instalar seus pacotes Python e atualizar seu PATH:

   export PATH=$PATH:~/.local/bin pip3 install -r requirements.txt --user

5. Defina variáveis para seu projeto, região e usuário atuais com estes comandos:

   export PROJECT_ID=$(gcloud config get-value project) export REGION=$(gcloud compute project-info describe \ --format="value(commonInstanceMetadata.items[google-compute-default-region])") export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)") export SERVICE_ACCOUNT="${PROJECT_NUMBER}-compute@developer.gserviceaccount.com"

Observação: se o Cloud Shell expirar ou reiniciar, você terá que inicializar as variáveis acima de novo.

6. Crie e abra um arquivo .env para autenticar o agente no diretório zoo_guide_agent com este comando:

   cloudshell edit .env

O diretório contendo o arquivo .env será aberto no editor do Cloud Shell.

7. Adicione seguinte texto ao arquivo .env e salve as alterações:

   MODEL="{{{ project_0.startup_script.gemini_flash_model_id | filled in at lab start }}}" SERVICE_ACCOUNT="${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" GOOGLE_GENAI_USE_ENTERPRISE=true GOOGLE_CLOUD_LOCATION=global

Conectar-se ao endpoint do servidor MCP seguro

Nesta seção, você estabelece uma conexão com o servidor MCP remoto.

1. Volte ao terminal do Cloud Shell e execute o comando abaixo para dar permissão à identidade do serviço do Cloud Run para chamar o servidor MCP remoto:

   gcloud projects add-iam-policy-binding $PROJECT_ID \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --role="roles/run.invoker"

2. Execute o comando abaixo para salvar o URL do servidor MCP em uma variável de ambiente:

   echo -e "\nMCP_SERVER_URL=https://zoo-mcp-server-${PROJECT_NUMBER}.${REGION}.run.app/mcp/" >> .env

3. Em seguida, execute o comando a seguir para criar o arquivo __init__.py. Esse arquivo informa ao Python que o diretório zoo_guide_agent é um pacote:

   cloudshell edit __init__.py

4. No editor do Cloud Shell que será aberto, adicione o seguinte código ao arquivo __init__.py e salve as alterações:

   from . import agent

Tarefa 2: criar o fluxo de trabalho do agente

Nessa tarefa, você vai configurar o fluxo de trabalho do agente guia turístico do zoológico. Comece importando as bibliotecas relevantes para a configuração inicial. Depois, defina os agentes especialistas e as ferramentas que o agente do zoológico vai usar. O próximo passo é definir o agente do fluxo de trabalho e, por fim, montar o fluxo de trabalho principal.

Criar o arquivo principal agent.py

• Volte ao terminal do Cloud Shell e execute o comando abaixo para criar o arquivo principal agent.py, que vai abrir no editor do Cloud Shell para você colar o código completo do sistema multiagente nas próximas etapas:

  cloudshell edit agent.py

Importar bibliotecas e fazer a configuração inicial

O primeiro bloco importa todas as bibliotecas necessárias do ADK e do Google Cloud. Ele também configura a geração de registros e carrega as variáveis de ambiente do arquivo .env, o que é essencial para acessar o modelo e o URL do servidor.

• Adicione este código ao arquivo agent.py:

  import os import sys import logging import google.cloud.logging from dotenv import load_dotenv # Add current directory for workspace utilities sys.path.append(os.path.dirname(os.path.abspath(__file__))) from google.adk import Agent from google.adk.agents import SequentialAgent from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset, StreamableHTTPConnectionParams from google.adk.tools.tool_context import ToolContext from google.adk.tools.langchain_tool import LangchainTool from langchain_community.tools import WikipediaQueryRun from langchain_community.utilities import WikipediaAPIWrapper import google.auth import google.auth.transport.requests import google.oauth2.id_token # --- Setup Logging and Environment --- cloud_logging_client = google.cloud.logging.Client() cloud_logging_client.setup_logging() load_dotenv() model_name = os.getenv("MODEL")

Definir ferramentas

A qualidade de um agente depende das ferramentas que ele pode usar. Nesta seção, você vai definir todos os recursos do seu agente, inclusive uma função personalizada para salvar dados, uma ferramenta MCP que se conecta ao seu servidor MCP seguro e uma ferramenta da Wikipédia.

• Adicione este código logo abaixo de agent.py:

  # Greet user and save their prompt def add_prompt_to_state( tool_context: ToolContext, prompt: str ) -> dict[str, str]: """Saves the user's initial prompt to the state.""" tool_context.state["PROMPT"] = prompt logging.info(f"[State updated] Added to PROMPT: {prompt}") return {"status": "success"} # Configuring the MCP Tool to connect to the Zoo MCP server mcp_server_url = os.getenv("MCP_SERVER_URL") if not mcp_server_url: raise ValueError("The environment variable MCP_SERVER_URL is not set.") def get_id_token(): """Get an ID token to authenticate with the MCP server.""" target_url = os.getenv("MCP_SERVER_URL") audience = target_url.split('/mcp/')[0] request = google.auth.transport.requests.Request() id_token = google.oauth2.id_token.fetch_id_token(request, audience) return id_token """ ## Use this code if you are using the public MCP Server and comment out the code below defining mcp_tools mcp_tools = MCPToolset( connection_params=StreamableHTTPConnectionParams( url=mcp_server_url ) ) """ mcp_tools = MCPToolset( connection_params=StreamableHTTPConnectionParams( url=mcp_server_url, headers={ "Authorization": f"Bearer {get_id_token()}", }, ), ) # Configuring the Wikipedia Tool wikipedia_tool = LangchainTool( tool=WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper()) )

Explicação das três ferramentas

• add_prompt_to_state: 📝 ferramenta que lembra o que os visitantes do zoológico perguntam. Quando um deles fala "Onde ficam os leões?", a ferramenta salva esse questionamento específico na memória para que os outros agentes no fluxo de trabalho saibam o que pesquisar.

  Como: uma função Python que grava o comando do visitante no dicionário compartilhado tool_context.state. O contexto da ferramenta representa a memória de curto prazo do agente para uma única conversa. Os dados salvos no estado por um agente podem ser lidos pelo próximo agente no fluxo de trabalho.

• MCPToolset: 🦁 usado para conectar o agente guia turístico ao servidor MCP do zoológico pré-implantado nesse laboratório. Esse servidor tem ferramentas especiais para pesquisar informações específicas sobre os animais do zoológico, como nome, idade e localização.

  Como: o servidor estabelece uma conexão segura com o URL do servidor particular do zoológico. Ele usa get_id_token para receber automaticamente um "cartão de acesso" seguro (um token de ID da conta de serviço) para comprovar a identidade e ter acesso.

• LangchainTool: 🌍 dá ao agente (guia turístico) conhecimento geral do mundo. Quando um visitante faz uma pergunta que não está no banco de dados do zoológico, como "O que comem os leões que vivem nas savanas?", a ferramenta permite que o agente procure a resposta na Wikipédia.

  Como: a ferramenta age como um adaptador, permitindo que o agente use a ferramenta pré-criada WikipediaQueryRun da biblioteca LangChain.

Recursos:

• Conjunto de ferramentas do MCP
• Ferramentas de função
• Estado

Definir agentes especializados

Nesta seção, você vai definir dois agentes especialistas: o de pesquisa e o formatador de respostas. O agente de pesquisa é o "cérebro" da sua operação. Ele recebe o comando do usuário do Estado compartilhado, examina as ferramentas avançadas do servidor MCP do zoológico e da Wikipédia e decide quais delas serão usadas para encontrar a resposta.

O papel do agente formatador de respostas é a apresentação. Ele não usa ferramentas para encontrar informações novas. Ele pega os dados brutos do agente de pesquisa que foram transmitidos usando o Estado e usa as habilidades de linguagem do LLM para criar uma resposta natural e conversacional.

• Adicione este código logo abaixo de agent.py:

  # 1. Researcher Agent comprehensive_researcher = Agent( name="comprehensive_researcher", model=model_name, description="The primary researcher that can access both internal zoo data and external knowledge from Wikipedia.", instruction=""" You are a helpful research assistant. Your goal is to fully answer the user's PROMPT. You have access to two tools: 1. A tool for getting specific data about animals AT OUR ZOO (names, ages, locations). 2. A tool for searching Wikipedia for general knowledge (facts, lifespan, diet, habitat). First, analyze the user's PROMPT. - If the prompt can be answered by only one tool, use that tool. - If the prompt is complex and requires information from both the zoo's database AND Wikipedia, you MUST use both tools to gather all necessary information. - Synthesize the results from the tool(s) you use into preliminary data outputs. PROMPT: {{ PROMPT }} """, tools=[ mcp_tools, wikipedia_tool ], output_key="research_data" # A key to store the combined findings ) # 2. Response Formatter Agent response_formatter = Agent( name="response_formatter", model=model_name, description="Synthesizes all information into a friendly, readable response.", instruction=""" You are the friendly voice of the Zoo Tour Guide. Your task is to take the RESEARCH_DATA and present it to the user in a complete and helpful answer. - First, present the specific information from the zoo (like names, ages, and where to find them). - Then, add the interesting general facts from the research. - If some information is missing, just present the information you have. - Be conversational and engaging. RESEARCH_DATA: {{ research_data }} """ )

Definir o agente de fluxo de trabalho

O agente de fluxo de trabalho age como o gerente dos "bastidores" do passeio pelo zoológico. Ele recebe um comando de pesquisa e garante que os dois agentes definidos na etapa 3 realizem as tarefas na ordem certa: primeiro a pesquisa, depois a formatação. Isso cria um processo previsível e confiável para responder às perguntas dos visitantes do zoológico.

Como: ele é um SequentialAgent, um tipo especial de agente que não pensa por conta própria. Sua única tarefa é executar uma lista de sub_agents (o pesquisador e o formatador) em uma sequência fixa, transmitindo automaticamente a memória compartilhada de um para o outro.

• Adicione este bloco de código logo abaixo de agent.py:

  tour_guide_workflow = SequentialAgent( name="tour_guide_workflow", description="The main workflow for handling a user's request about an animal.", sub_agents=[ comprehensive_researcher, # Step 1: Gather all data response_formatter, # Step 2: Format the final response ] )

Montar o fluxo de trabalho principal

O fluxo de trabalho principal é definido por meio do root_agent, o que é usado pela estrutura do ADK como ponto de partida para todas as novas conversas. A função principal desse agente é coordenar o processo geral. Ele age como o controlador inicial, cuidando do primeiro turno da conversa.

• Adicione este último bloco de código logo abaixo de agent.py e salve as alterações:

  root_agent = Agent( name="greeter", model=model_name, description="The main entry point for the Zoo Tour Guide.", instruction=""" - Let the user know you will help them learn about the animals we have in the zoo. - When the user responds, use the 'add_prompt_to_state' tool to save their response. After using the tool, transfer control to the 'tour_guide_workflow' agent. """, tools=[add_prompt_to_state], sub_agents=[tour_guide_workflow] )

Seu arquivo agent.py está concluído.

Fazendo assim, você entende como cada componente (ferramentas, agentes de worker e agentes de gerenciamento) tem um papel específico na criação do sistema inteligente final. Próxima parada: implantação!

Tarefa 3: preparar o aplicativo para implantação

Com o ambiente local pronto, a próxima etapa é preparar o projeto do Google Cloud para a implantação do agente guia turístico do zoológico.

Para isso, é preciso fazer uma verificação final da estrutura de arquivos do agente para garantir que ela seja compatível com o comando de implantação. Ainda mais importante é configurar uma permissão crítica do IAM para que o serviço do Cloud Run atue em seu nome e chame os modelos da Agent Platform. A conclusão dessa etapa garante que o ambiente de nuvem está pronto para executar o agente.

1. Volte ao terminal do Cloud Shell e execute este comando para carregar as variáveis na sua sessão do shell:

   source .env

2. Execute o comando a seguir para conceder à conta de serviço o papel de usuário da Agent Platform com permissão para fazer previsões e chamar modelos do Google:

   # Grant the "Agent Platform User" role to your service account gcloud projects add-iam-policy-binding $PROJECT_ID \ --member="serviceAccount:$SERVICE_ACCOUNT" \ --role="roles/aiplatform.user"

Tarefa 4: implantar o agente usando a CLI do ADK

Com o código local pronto e o projeto do Google Cloud preparado, é hora de implantar o agente.

Nessa tarefa, você vai usar o comando adk deploy cloud_run, uma ferramenta conveniente que automatiza todo o fluxo de trabalho de implantação. Esse comando único empacota seu código, cria uma imagem do contêiner, envia-a para o Artifact Registry e executa o serviço no Cloud Run para que ele fique acessível na web.

Implantar o agente

1. Execute este comando para implantar o agente:

   # Run the deployment command adk deploy cloud_run \ --project=$PROJECT_ID \ --region=$REGION \ --service_name=zoo-tour-guide \ --with_ui \ .

2. Se for perguntado se você quer continuar e/ou permitir invocações não autenticadas em [zoo-tour-guide], digite Y em todos os casos e pressione ENTER.

Observação: a execução do comando de implantação pode levar de 5 a 10 minutos.

3. Execute o comando abaixo para mudar as configurações do serviço do Cloud Run atual:

   gcloud run services update zoo-tour-guide \ --region=$REGION \ --update-labels=dev-tutorial=codelab-adk \ --set-env-vars="MODEL=$MODEL,MCP_SERVER_URL=$MCP_SERVER_URL,GOOGLE_CLOUD_LOCATION=global"

Acessar o link de implantação

• Depois que o agente for implantado no Cloud Run, ele vai gerar o URL do serviço, que você pode usar para abrir em uma nova guia do navegador.

  O URL provavelmente terá o formato a seguir. Saída de URL do serviço:

  https://zoo-tour-guide-{{{project_0.startup_script.project_number | filled in at lab start}}}.{{{project_0.default_region | filled in at lab start}}}.run.app

Como você usou a flag --with_ui ao implantar no Cloud Run, a interface do desenvolvedor do ADK deve ser exibida.

Observação: qualquer pessoa pode acessar esse agente usando o URL. Por isso, essa abordagem é mais adequada para fins de teste. Observação: pode levar alguns minutos para que a verificação de monitoramento da atividade seja aprovada após uma implantação bem-sucedida.

Clique em Verificar meu progresso para conferir o objetivo. Implantar o agente

Tarefa 5: testar o agente implantado

Com o agente ativo no Cloud Run, chegou a hora de fazer um teste para confirmar se tudo correu bem na implantação e se ele está funcionando como esperado. Você precisa usar o URL do serviço público para acessar a interface da web do ADK e interagir com o agente.

1. Abra o URL público do serviço do Cloud Run gerado na tarefa anterior no seu navegador da web ou pressione CTRL e clique no URL da saída para abrir uma nova guia do navegador. A interface de desenvolvedor do ADK será aberta.

   Se você receber uma notificação perguntando se quer que o Cloud Shell abra o site externo, clique em Abrir para confirmar.

2. Deixe a opção Streaming de token Ativada no canto superior direito da barra de ferramentas do ADK.

Pronto! Você já pode interagir com o agente do zoológico.

3. Digite o seguinte na caixa de comando e pressione ENTER para iniciar uma nova conversa:

Hello

Observe o resultado. O agente deve responder rapidamente com a saudação padrão:

"Hello! I'm your Zoo Tour Guide. I can help you learn about the amazing animals we have here. What would you like to know or explore today?"

4. Interaja com o agente guia do zoológico. Insira o comando a seguir para retomar a conversa:

Where are the penguins located?

Você vai receber uma resposta parecida com esta:

5. Teste estes comandos adicionais para ver como o agente usa diferentes ferramentas (MCP x Wikipédia) e combina informações:

Para testar o conhecimento geral (somente Wikipédia):

What is the average lifespan of a penguin in the wild?

Para testar a combinação de dados internos e externos:

What species are the penguins in our zoo, and what do they typically eat in the wild?

Sobre leões (testando as duas ferramentas novamente):

Where are the lions and what do they eat in the wild?

Sobre ursos polares (teste para animais que talvez não estejam no zoológico):

Do we have polar bears in this zoo?

Explicação do fluxo do agente

Seu sistema opera como uma equipe inteligente e com vários agentes. O processo é guiado por uma sequência clara para garantir um fluxo tranquilo e eficiente, da pergunta do usuário à resposta final detalhada.

1. Agente de boas-vindas do zoológico (a recepção)

O processo começa com o agente de boas-vindas

Função: começar a conversa. A instrução dele é cumprimentar o usuário e perguntar sobre qual animal ele quer informações.

Ferramenta: quando o usuário responde, o agente de boas-vindas usa add_prompt_to_state para capturar as palavras exatas, por exemplo, "fale sobre os leões", e as salva na memória do sistema.

Transferência: depois de salvar o comando, o controle passa imediatamente para o subagente tour_guide_workflow.

2. Pesquisador Geral (o mestre das pesquisas)

Essa é a primeira etapa do fluxo de trabalho principal, o "cérebro" da operação. Em vez de uma equipe, você passa a interagir com um único agente altamente qualificado que tem acesso a todas as informações disponíveis.

Função: analisar a pergunta do usuário e criar um plano inteligente. Com o recurso avançado de uso de ferramentas do modelo de linguagem, o agente decide se precisa de:

• Dados internos dos registros do zoológico (por meio do servidor MCP).
• Conhecimento geral da web (pela API Wikipedia).
• Ou dos dois, em caso de perguntas mais complexas.

Ação: o agente executa as ferramentas necessárias para coletar todos os dados brutos exigidos. Por exemplo, se perguntarem "Quantos anos os leões têm e o que comem os que vivem na savanaa?", ele vai chamar o servidor MCP para responder sobre as idades e a Wikipedia para encontrar informações sobre a dieta.

3. Formatador de respostas (o apresentador)

Com todos os fatos reunidos pelo Pesquisador Geral, esse é o último agente a ser executado.

Função: ser o guia amigável do zoológico. Ele reúne e melhora a qualidade dos dados brutos (de uma ou de ambas as fontes).

Ação: resumir todas as informações em uma resposta individual, coerente e interessante. Seguindo as instruções, ele começa apresentando as informações específicas do zoológico e depois apresenta fatos gerais interessantes.

O resultado final: o texto gerado por esse agente é a resposta completa e detalhada que aparece para o usuário na tela da conversa.

Tarefa 6: limpar o ambiente

Para evitar custos futuros, nessa tarefa você vai excluir os recursos do Cloud criados no laboratório.

• Volte para a guia do terminal do Cloud Shell e execute este comando:

  gcloud run services delete zoo-tour-guide --region=$REGION --quiet gcloud artifacts repositories delete cloud-run-source-deploy --location=$REGION --quiet

Próximas etapas / Saiba mais

Para mais informações sobre a criação de agentes, confira estes recursos:

• Documentos do ADK
• Como criar ferramentas personalizadas para agentes

Parabéns!

Neste laboratório, você aprendeu a estruturar projetos Python para implantação usando a interface de linha de comando do ADK, implementou um fluxo de trabalho multiagente, conectou-se a um servidor MCP remoto para usar as ferramentas dele, melhorou dados internos integrando ferramentas externas como a API Wikipedia e implantou o agente como um contêiner sem servidor no Cloud Run.

Manual atualizado em 21 de julho de 2026

Laboratório testado em 21 de julho 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.