Criar e implantar um agente do ADK no Cloud Run

1. Introdução

Este laboratório é voltado à implementação e à implantação de um serviço de agente cliente. Você vai usar o Kit de Desenvolvimento de Agente (ADK) para criar um agente de IA que usa ferramentas.

Neste laboratório, vamos criar um agente de zoológico que usa a Wikipédia para responder perguntas sobre animais.

Por fim, vamos implantar o agente de guia turístico no Cloud Run do Google, em vez de apenas executar localmente.

Pré-requisitos

• Ter um projeto do Google Cloud com o faturamento ativado.

O que você vai aprender

• Como estruturar um projeto Python para implantação do ADK.
• Como implementar um agente que usa ferramentas com o google-adk.
• Como implantar um aplicativo Python como um contêiner sem servidor no Cloud Run.
• Como configurar a autenticação segura de serviço para serviço usando papéis do IAM.
• Como excluir recursos do Cloud para evitar custos futuros.

O que é necessário

• Uma conta e um projeto do Google Cloud
• Um navegador da Web, como o Chrome

2. Por que implantar no Cloud Run?

O Cloud Run é uma ótima opção para hospedar agentes do ADK porque é uma plataforma sem servidor. Isso significa que você pode se concentrar no código e não em gerenciar a infraestrutura subjacente. Nós cuidamos do trabalho operacional para você.

Pense nele como uma loja pop-up: ela só abre e usa recursos quando há clientes (solicitações). Se nenhum cliente aparece, ela fecha completamente. Assim, você não paga por uma loja vazia.

Principais recursos

Executa contêineres em qualquer lugar:

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

Escalonamento automático:

• Se ninguém estiver usando seu app → nenhuma instância será executada (reduz para zero instância, o que é econômico).
• 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 direcionada a uma instância diferente.
• Se você precisar armazenar estado, use um serviço externo como Cloud SQL, Firestore ou Memorystore.

Funciona com qualquer linguagem ou framework:

• Desde que possa ser 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:

• Faturamento com base em solicitações: cobrança por solicitação + tempo de computação (até 100 ms).
• Faturamento com base em instâncias: cobrado pelo ciclo de vida completo da instância (sem taxa por solicitação).

3. Configurar o projeto

Conta do Google

Se você ainda não tiver uma Conta do Google pessoal, crie uma.

Use uma conta pessoal em vez de uma conta escolar ou de trabalho.

As contas escolares e de trabalho podem ter restrições que impedem a ativação das APIs necessárias para este laboratório.

Fazer login no console do Google Cloud

Faça login no console do Google Cloud usando uma Conta do Google pessoal.

Ativar faturamento

Configurar uma conta de faturamento pessoal

Se você configurou o faturamento usando créditos do Google Cloud, pule esta etapa.

Para configurar uma conta de faturamento pessoal, acesse este link para ativar o faturamento no console do Cloud.

Algumas observações:

• A conclusão deste laboratório custa menos de US $1 em recursos do Cloud.
• Siga as etapas no final deste laboratório para excluir recursos e evitar mais cobranças.
• Novos usuários podem aproveitar a avaliação sem custos financeiros de US$300.

Criar um projeto (opcional)

Se você não tiver um projeto atual que gostaria de usar neste laboratório, crie um novo aqui.

4. Abrir editor do Cloud Shell

1. Clique neste link para navegar diretamente até o editor do Cloud Shell.
2. Se for preciso autorizar em algum momento hoje, clique em Autorizar para continuar.
3. Se o terminal não aparecer na parte de baixo da tela, abra-o:
   • Clique em Visualizar.
   • Clique em Terminal.

5. Ativar APIs

Para usar o Cloud Run, o Artifact Registry, o Cloud Build, a Vertex AI e o Compute Engine, é necessário ativar as respectivas APIs no seu projeto do Google Cloud.

• No terminal, ative as APIs:

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

  Quando a execução terminar, você vai encontrar uma saída como esta:

  Operation "operations/acat.p2-[GUID]" finished successfully.
  

Apresentação das APIs

• A API Cloud Run Admin (run.googleapis.com) permite executar serviços de front-end e back-end, jobs em lote ou sites em um ambiente totalmente gerenciado. Ele lida com a infraestrutura para implantação e escalonamento dos seus aplicativos conteinerizados.
• A API Artifact Registry (artifactregistry.googleapis.com) oferece um repositório seguro e particular para armazenar suas imagens de contêiner. Ele é a evolução do Container Registry e se integra perfeitamente ao Cloud Run e ao Cloud Build.
• A API Cloud Build (cloudbuild.googleapis.com) é uma plataforma de CI/CD sem servidor que executa seus builds na infraestrutura do Google Cloud. Ele é usado para criar a imagem de contêiner na nuvem com base no Dockerfile.
• A API Vertex AI (aiplatform.googleapis.com) permite que seu aplicativo implantado se comunique com os modelos do Gemini para realizar tarefas principais de IA. Ela fornece a API unificada para todos os serviços de IA do Google Cloud.
• A API Compute Engine (compute.googleapis.com) oferece máquinas virtuais seguras e personalizáveis que são executadas na infraestrutura do Google. Embora o Cloud Run seja gerenciado, a API Compute Engine é frequentemente necessária como uma dependência fundamental para vários recursos de rede e computação.

6. Preparar seu ambiente de desenvolvimento

Criar o diretório

1. No terminal, crie o diretório do projeto e os subdiretórios necessários:

   cd && mkdir zoo_guide_agent && cd zoo_guide_agent
   

2. No terminal, execute o comando a seguir para abrir o diretório zoo_guide_agent no explorador do Editor do Cloud Shell:

   cloudshell open-workspace ~/zoo_guide_agent
   

3. O painel do explorador à esquerda será atualizado. Agora você vai encontrar o diretório que criou.
   
   

   Se o terminal desaparecer ao fazer isso, clique em Visualizar e depois em Terminal no menu superior para reabri-lo.

Definir o projeto

1. No terminal, defina o projeto com este comando:

   gcloud config set project [PROJECT_ID]
   

   Exemplo: gcloud config set project lab-project-id-example

   Se você não se lembrar do ID do projeto, liste todos os IDs com: gcloud projects list

   
2. Você vai receber esta mensagem:

   Updated property [core/project].
   

   Se você vir um WARNING e for perguntado Do you want to continue (Y/n)?, provavelmente inseriu o ID do projeto incorretamente. Pressione n, Enter e tente executar o comando gcloud config set project novamente.

Requisitos de instalação

1. Execute o comando a seguir no terminal para criar o arquivo requirements.txt.

   cloudshell edit requirements.txt
   

2. Adicione o seguinte ao arquivo requirements.txt recém-criado:

   google-adk==1.14.0
   langchain-community==0.3.27
   wikipedia==1.4.0
   

3. No terminal, crie e ative um ambiente virtual usando o uv. Isso garante que as dependências do projeto não entrem em conflito com o Python do sistema.

   uv venv
   source .venv/bin/activate
   

   Observação: se a sessão do Cloud Shell for atualizada ou se você abrir uma nova guia do terminal, talvez seja necessário reativar o ambiente virtual executando source .venv/bin/activate.

4. Instale os pacotes necessários no ambiente virtual no terminal.

   uv pip install -r requirements.txt
   

Configurar variáveis de ambiente

• Use o comando a seguir no terminal para criar o arquivo .env.

  # 1. Set the variables in your terminal first
  PROJECT_ID=$(gcloud config get-value project)
  PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
  SA_NAME=lab2-cr-service
  
  # 2. Create the .env file using those variables
  cat <<EOF > .env
  PROJECT_ID=$PROJECT_ID
  PROJECT_NUMBER=$PROJECT_NUMBER
  SA_NAME=$SA_NAME
  SERVICE_ACCOUNT=${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
  MODEL="gemini-2.5-flash"
  EOF
  

  Verifique o arquivo .env e confira se PROJECT_ID, PROJECT_NUMBER e SERVICE_ACCOUNT receberam valores. Se os detalhes do projeto estiverem faltando, execute gcloud projects list para encontrá-los. Se a conta de serviço estiver faltando, liste as contas no seu projeto para encontrar o endereço de e-mail (ele termina em .iam.gserviceaccount.com) executando: gcloud iam service-accounts list.

7. Criar fluxo de trabalho do agente

Criar arquivo __init__.py

1. Crie o arquivo init.py executando o seguinte no terminal:

   cloudshell edit __init__.py
   

   Esse arquivo informa ao Python que o diretório zoo_guide_agent é um pacote.
2. Adicione o seguinte código ao novo arquivo __init__.py:

   from . import agent
   

Crie o arquivo agent.py.

1. Cole o comando a seguir no terminal para criar o arquivo agent.py principal.

   cloudshell edit agent.py
   

2. Importações e configuração inicial: adicione o seguinte código ao arquivo agent.py, que está vazio:

   import os
   import logging
   import google.cloud.logging
   from dotenv import load_dotenv
   
   from google.adk import Agent
   from google.adk.agents import SequentialAgent
   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")
   

   O primeiro bloco do arquivo agent.py traz todas as bibliotecas necessárias do ADK e do Google Cloud. Ele também configura a criação de registros em log e carrega as variáveis de ambiente do arquivo .env, o que é essencial para acessar o modelo e o URL do servidor.
3. Defina as ferramentas: a qualidade de um agente é limitada às ferramentas que ele pode usar. Adicione o seguinte código à parte de baixo de agent.py para definir as ferramentas:

   # 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 Wikipedia Tool
   wikipedia_tool = LangchainTool(
       tool=WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
   )
   

   The Tools Explained
   (em inglês)
   • add_prompt_to_state 📝: ferramenta que lembra as perguntas dos visitantes do zoológico. Quando um visitante pergunta "Onde estão os leões?", a ferramenta salva essa pergunta específica 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 no fluxo de trabalho.
   • LangchainTool 🌍: dá ao agente de 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 leões comem na natureza?", 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.
     
     
4. Defina os agentes especialistas: adicione o seguinte código à parte de baixo de agent.py para definir os agentes comprehensive_researcher e response_formatter:

   # 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=[
           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 }
       """
   )
   

   • O agente comprehensive_researcher é o "cérebro" da nossa operação. Ele recebe o comando do usuário do State compartilhado, examina a ferramenta da Wikipédia e decide quais usar para encontrar a resposta.
   • O papel do agente response_formatter é a apresentação. Ele pega os dados brutos do agente de pesquisa que foram passados pelo Estado e usa a habilidade de linguagem do LLM para criar uma resposta natural e conversacional.
     
5. Defina o agente do fluxo de trabalho: adicione este bloco de código à parte de baixo de agent.py para definir o agente sequencial tour_guide_workflow:

   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
       ]
   )
   

   O agente de fluxo de trabalho age como o gerente dos "bastidores" do passeio pelo zoológico. Ele recebe o comando de pesquisa e garante que os dois agentes definidos acima façam os trabalhos 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.
   Como:ele é um SequentialAgent, um tipo especial de agente que não pensa por conta própria. Seu único trabalho é 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.
6. Monte o fluxo de trabalho principal: adicione este bloco de código final à parte de baixo de agent.py para definir o root_agent:

   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]
   )
   

   A estrutura ADK usa o root_agent como ponto de partida para todas as novas conversas. A função principal dele é orquestrar o processo geral. Ele age como o controlador inicial, cuidando do primeiro turno da conversa.
   

O arquivo agent.py completo

Seu arquivo agent.py está pronto. Criando desse jeito, você entende como cada componente (ferramentas, agentes de worker e agentes de gerenciamento) tem um papel específico para entregar o sistema inteligente final.

O arquivo completo vai ficar assim:

import os
import logging
import google.cloud.logging
from dotenv import load_dotenv

from google.adk import Agent
from google.adk.agents import SequentialAgent
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")

# 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 Wikipedia Tool
wikipedia_tool = LangchainTool(
    tool=WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
)

# 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=[
        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 }
    """
)

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
    ]
)

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]
)

Próxima parada: implantação!

8. prepare o aplicativo para implantação

Verificar a estrutura final

Antes de fazer a implantação, verifique se o diretório do projeto contém os arquivos corretos.

• Verifique se a pasta zoo_guide_agent está assim:

  zoo_guide_agent/
  ├── .env
  ├── __init__.py
  ├── agent.py
  └── requirements.txt
  

Configurar permissões do IAM

Com o código local pronto, a próxima etapa é configurar a identidade que o agente vai usar na nuvem.

1. No terminal, carregue as variáveis na sua sessão do shell.

   source .env
   

   Observação:se a sessão do Cloud Shell for atualizada ou se você abrir uma nova guia do terminal, talvez seja necessário executar source .env novamente para recarregar essas variáveis.

2. Crie uma conta de serviço dedicada para seu serviço do Cloud Run para que ele tenha permissão específica. Cole o seguinte no terminal:

   gcloud iam service-accounts create ${SA_NAME} \
       --display-name="Service Account for lab 2 "
   

   Ao criar uma identidade dedicada para esse aplicativo específico, você garante que o agente tenha apenas as permissões exatas de que precisa, em vez de usar uma conta padrão com acesso muito amplo.
3. Conceda à conta de serviço a função de usuário da Vertex AI, que dá permissão para chamar os modelos do Google.

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

9. implante 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. 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 de contêiner, envia para o Artifact Registry e executa o serviço no Cloud Run, tornando-o acessível na Web.

1. Execute o comando a seguir no terminal para implantar o agente.

   # Run the deployment command
   uvx --from google-adk \
   adk deploy cloud_run \
     --project=$PROJECT_ID \
     --region=europe-west1 \
     --service_name=zoo-tour-guide \
     --with_ui \
     . \
     -- \
     --labels=dev-tutorial=codelab-adk \
     --service-account=$SERVICE_ACCOUNT
   

   O comando uvx permite executar ferramentas de linha de comando publicadas como pacotes Python sem exigir uma instalação global dessas ferramentas.

   Observação:a execução do comando de implantação abaixo leva alguns minutos.

2. Se a seguinte mensagem aparecer:

   Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region 
   [europe-west1] will be created.
   
   Do you want to continue (Y/n)?
   

   Se for o caso, digite Y e pressione ENTER.
3. Se a seguinte mensagem aparecer:

   Allow unauthenticated invocations to [your-service-name] (y/N)?.
   

   Digite y e pressione ENTER. Isso permite invocações não autenticadas para este laboratório, facilitando os testes.

   Observação:qualquer pessoa com o URL terá acesso a esse agente. Por isso, essa abordagem é mais adequada para testes.

   Após a execução bem-sucedida, o comando vai fornecer o URL do serviço do Cloud Run implantado. Ele vai ficar parecido com https://zoo-tour-guide-123456789.europe-west1.run.app.
4. Copie o URL do serviço do Cloud Run implantado para a próxima tarefa.

10. teste o agente implantado

Com o agente ativo no Cloud Run, faça um teste para confirmar se a implantação foi bem-sucedida e se o agente está funcionando como esperado. Você vai usar o URL do serviço público (algo como https://zoo-tour-guide-123456789.europe-west1.run.app/) 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 no navegador da Web. Como você usou o --with_ui flag, a interface do desenvolvedor do ADK vai aparecer.
2. Ative a opção Token Streaming no canto superior direito.
   Agora você pode interagir com o agente do zoológico.
3. Digite hello e pressione "Enter" para iniciar uma nova conversa.
4. Observe o resultado. O agente deve responder rapidamente com a saudação, que será algo assim:

   "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?"
   

5. Faça perguntas ao agente, como:

   Where can I find the polar bears in the zoo and what is their diet?
   

   

Explicação do fluxo de agentes

Seu sistema funciona como uma equipe multiagente inteligente. 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)

Todo o processo começa com o agente recepcionista.

• Função: começar a conversa. A instrução é cumprimentar o usuário e perguntar sobre qual animal ele quer saber mais.
• Ferramenta: quando o usuário responde, o Recepcionista usa add_prompt_to_state para capturar as palavras exatas, por exemplo, "fale sobre os leões" e salvar 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 de uso de ferramentas do modelo de linguagem, o agente decide se precisa de:
  • Conhecimento geral da web (pela API Wikipedia).
  • Ou dos dois, em caso de perguntas mais complexas.

3. O formatador de respostas (o apresentador)

Depois que o Pesquisador Geral reúne todos os fatos, esse é o último agente a ser executado.

• Função: ser nosso guia amigável do zoológico. Ele pega dados brutos de uma ou das duas fontes e melhora a qualidade deles.
• 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 conta fatos gerais interessantes.
• O resultado final: o texto gerado por esse agente é a resposta completa e detalhada que aparece na tela da conversa para o usuário.

Se você quiser saber mais sobre como criar agentes, confira estes recursos:

1. Documentos do ADK
2. Como criar ferramentas personalizadas para agentes do ADK

11. Limpar o ambiente

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto ou mantenha o projeto e exclua cada um dos recursos.

Excluir os serviços e imagens do Cloud Run

Se você quiser manter o projeto do Google Cloud, mas remover os recursos específicos criados neste laboratório, exclua o serviço em execução e a imagem do contêiner armazenada no registro.

• Execute os seguintes comandos no terminal:

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

Excluir o projeto (opcional)

Se você criou um projeto especificamente para este laboratório e não pretende usá-lo novamente, a maneira mais fácil de fazer a limpeza é excluir o projeto inteiro. Isso garante que todos os recursos (incluindo a conta de serviço e os artefatos de build ocultos) sejam completamente removidos.

• No terminal, execute o comando a seguir (substitua [YOUR_PROJECT_ID] pelo ID do seu projeto):

  gcloud projects delete $PROJECT_ID
  

  A exclusão de um projeto é irreversível. Antes de continuar, verifique se o projeto não está sendo usado para nenhum outro trabalho.

12. Parabéns

Você criou e implantou um aplicativo de IA multiagente no Google Cloud.

Recapitulação

Neste laboratório, você passou de um diretório vazio para um serviço de IA ativo e acessível ao público. Confira o que você criou:

• Você criou uma equipe especializada: em vez de uma IA genérica, você criou um "Pesquisador" para encontrar fatos e um "Formatador" para refinar a resposta.
• Você deu ferramentas a eles: você conectou seus agentes ao mundo externo usando a API da Wikipédia.
• Você fez a entrega: você pegou seu código Python local e o implantou como um contêiner sem servidor no Cloud Run, protegendo-o com uma conta de serviço dedicada.

O que aprendemos

• Como estruturar um projeto Python para implantação com o ADK.
• Como implementar um fluxo de trabalho multiagente usando [SequentialAgent](https://google.github.io/adk-docs/agents/workflow-agents/sequential-agents/).
• Como integrar ferramentas externas, como a API da Wikipédia.
• Como implantar um agente no Cloud Run usando o comando adk deploy.

13. Pesquisa

Saída:

Como você usará este tutorial?

Apenas leitura Leitura e exercícios