1. Objetivo deste laboratório
Neste laboratório prático, você vai criar um aplicativo multiagente usando o ADK (Kit de Desenvolvimento de Agente) , que gera uma imagem com base no seu comando e a avalia em relação a ele. Se a imagem não atender satisfatoriamente aos requisitos descritos no comando, o agente vai gerar imagens continuamente até que uma delas atenda aos seus requisitos. Cada um dos agentes neste exercício prático tem um único propósito, e eles cooperam entre si para alcançar a meta geral. Você vai aprender a testar o aplicativo localmente e implantar no Vertex AI Agent Engine.
Tópicos de aprendizagem
- Entenda os conceitos básicos do ADK (Kit de Desenvolvimento de Agente) e aprenda a criar um sistema multiagente.
- Aprenda a implantar e usar facilmente os agentes no Vertex AI Agent Engine.
- Entenda os conceitos básicos do protocolo A2A
- Aprenda a usar o protocolo A2A e o ADK (Kit de Desenvolvimento de Agentes) juntos para criar agentes abertos.
2. Configuração do projeto
- Se você ainda não tiver um projeto para usar, crie um novo no console do GCP.
- Neste laboratório, vamos usar o GCP Cloud Shell para realizar nossas tarefas. Abra o Cloud Shell e defina o projeto usando o Cloud Shell.
- Abra o Cloud Shell do GCP clicando aqui: Cloud Shell . Se o pop-up "Autorizar Shell" aparecer, clique para autorizar o editor do Cloud Shell.
- Para verificar se o projeto já está autenticado, use o seguinte comando no terminal do Cloud Shell.
gcloud auth list
- Execute o comando a seguir no Cloud Shell para confirmar seu projeto:
gcloud config list project
- Copie o ID do projeto e use o comando a seguir para defini-lo:
gcloud config set project <YOUR_PROJECT_ID>
- Precisamos ativar alguns serviços para executar este laboratório. Execute o seguinte comando no Cloud Shell:
gcloud services enable aiplatform.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com
3. Introdução ao Kit de Desenvolvimento de Agente
O Kit de Desenvolvimento de Agente oferece várias vantagens importantes para desenvolvedores que criam aplicativos agênticos:
- Sistemas multiagentes: crie aplicativos modulares e escalonáveis ao organizar vários agentes especializados em uma hierarquia. Coordene e delegue fluxos complexos.
- Ecossistema de ferramentas avançado: atribua diversos recursos aos agentes ao usar ferramentas pré-criadas (pesquisa, execução de código etc.), crie funções personalizadas, integre ferramentas de frameworks de agentes de terceiros (LangChain, CrewAI) ou utilize outros agentes como ferramentas.
- Orquestração flexível: defina fluxos de trabalho usando agentes de fluxo de trabalho (
SequentialAgent,ParallelAgenteLoopAgent) para pipelines previsíveis ou aproveite o roteamento dinâmico orientado por LLM (transferência deLlmAgent) para um comportamento adaptativo. - Experiência integrada do desenvolvedor: desenvolva, teste e depure localmente com uma CLI avançada e uma interface de desenvolvimento interativa. Inspecione eventos, estado e a execução do agente etapa por etapa.
- Avaliação integrada: avalie sistematicamente o desempenho do agente avaliando a qualidade da resposta final e a trajetória de execução detalhada de casos de teste predefinidos.
- Pronto para implantação: transforme seus agentes em contêineres e implante em qualquer lugar. Execute localmente, escalone com o Vertex AI Agent Engine ou faça a integração a uma infraestrutura personalizada usando o Cloud Run ou o Docker.
Embora outros SDKs de IA generativa e frameworks de agentes permitam consultar modelos e até integrá-los a ferramentas, a coordenação dinâmica entre múltiplos modelos ainda demanda considerável esforço da sua parte.
O Kit de Desenvolvimento de Agente oferece um framework de alto nível em comparação com essas ferramentas, permitindo conectar e manter vários agentes em fluxos de trabalho complexos de forma fácil.
Figura 1: posicionamento do ADK (Kit de Desenvolvimento de Agente)
4. Introdução ao Vertex AI Agent Engine
O Vertex AI Agent Engine é um serviço totalmente gerenciado para implantar agentes no Google Cloud. Com o Vertex AI Agent Engine, os desenvolvedores podem desenvolver, personalizar, implantar, veicular e gerenciar agentes de IA de código aberto( ADK (Kit de Desenvolvimento de Agentes) , LangChain, LangGraph, CrewAI, AutoGen e muito mais) na Vertex AI.
O Agent Engine também oferece serviços para processar os dados do usuário, também conhecidos como memória do agente. Atualmente, há dois tipos de serviços de memória disponíveis.
- Memória de curto prazo: com as sessões do Agent Engine, é possível armazenar, gerenciar e recuperar o histórico de conversas em andamento (estado) em uma única sessão como memória de curto prazo.
- Memória de longo prazo: com o Memory Bank do Agent Engine, armazene, transforme e recupere memórias (estado), principalmente em várias sessões como memórias de longo prazo.
Você também pode implantar agentes em outros serviços do Google Cloud, como o Cloud Run ou o GKE. Considere usar o Vertex AI Agent Engine para os seguintes casos de uso:
- Ambiente de execução gerenciado com estado: se você precisar de um ambiente de execução com estado e totalmente gerenciado para a implantação do seu agente, o Vertex AI Agent Engine é uma boa opção, já que abstrai tarefas comuns, como gerenciamento de sessões e persistência para agentes de IA.
- Execução de código: se o agente precisar executar um código gerado dinamicamente durante a sessão do usuário, o Agent Engine vai fornecer um sandbox seguro para isso.
- Memória de longo prazo flexível: se você precisar de memória de longo prazo flexível para seus agentes, o Memory Bank da Vertex AI, que pode ser usado com o Vertex AI Agent Engine, oferece uma maneira flexível de lembrar as informações sobre o usuário que podem ser usadas em todas as sessões.
Também é possível combinar o Vertex AI Agent Engine com outros ambientes de execução, como o Cloud Run, para criar uma arquitetura de aplicativo flexível. Confira abaixo um exemplo de arquitetura de referência usando vários serviços para criar um agente.
Figura 2: um exemplo de arquitetura de referência para criar agentes usando vários serviços.
5. Introdução ao A2A
O protocolo Agent2Agent (A2A) é um padrão aberto projetado para permitir a comunicação e a colaboração perfeitas e seguras entre agentes autônomos de IA de diferentes frameworks, fornecedores e domínios.
- Interoperabilidade universal:o A2A permite que os agentes trabalhem juntos, independentemente das tecnologias subjacentes, promovendo um ecossistema multiagente de verdade. Isso significa que agentes criados por empresas diferentes em plataformas diferentes podem se comunicar e coordenar.
- Descoberta de recursos:os agentes podem anunciar seus recursos usando "cards de agente" (documentos JSON), que descrevem a identidade, os recursos A2A compatíveis, as habilidades e os requisitos de autenticação. Isso permite que outros agentes descubram e selecionem o mais adequado para uma determinada tarefa.
- Proteção sempre:a segurança é um princípio fundamental. O A2A incorpora mecanismos de autenticação e autorização de nível empresarial, usando padrões como HTTPS/TLS, JWT, OIDC e chaves de API para garantir interações seguras e proteger dados sensíveis.
- Independente da modalidade:o protocolo é compatível com várias modalidades de comunicação, incluindo texto, áudio e streaming de vídeo, além de formulários interativos e iframes incorporados. Essa flexibilidade permite que os agentes troquem informações no formato mais adequado para a tarefa e o usuário.
- Gerenciamento estruturado de tarefas:o A2A define protocolos claros para delegação, monitoramento e conclusão de tarefas. Ele permite agrupar e gerenciar tarefas relacionadas em diferentes agentes usando IDs de tarefa exclusivos. As tarefas podem passar por ciclos de vida definidos (por exemplo, enviada, em andamento, concluída).
- Execução opaca:um recurso importante é que os agentes não precisam revelar a outros agentes os processos internos de raciocínio, a memória ou as ferramentas específicas. Eles expõem apenas os serviços chamáveis, promovendo modularidade e privacidade.
- Criado com base em padrões atuais:o A2A usa tecnologias da Web estabelecidas, como HTTP, eventos enviados pelo servidor (SSE) para streaming em tempo real e JSON-RPC para troca de dados estruturados, facilitando a integração com a infraestrutura de TI atual.
- Comunicação assíncrona:o protocolo foi projetado com a comunicação assíncrona como uma consideração principal, facilitando a progressão flexível de tarefas e permitindo notificações push para atualizações, mesmo quando uma conexão não é mantida de forma persistente.
6. Arquitetura do agente
Neste laboratório, você vai criar um aplicativo multiagente que gera uma imagem de acordo com sua especificação e a avalia antes de apresentar a você.
O sistema é estruturado com um agente principal chamado image_scoring, que organiza todo o processo. Esse agente principal tem um subagente chamado image_generation_scoring_agent, que por sua vez tem subagentes próprios para tarefas mais específicas. Isso cria uma relação hierárquica em que o agente principal delega tarefas aos subagentes. 
Figura 3: fluxo geral do agente.
Lista de todos os agentes
Agente | Purpose | Subagentes |
image_scoring (agente principal) | Esse é o agente raiz que gerencia o fluxo de trabalho geral. Ele executa repetidamente o image_generation_scoring_agent e o checker_agent em um loop até que uma condição de encerramento seja atendida. | image_generation_scoring_agent |
image_generation_scoring_agent (subagente de image_scoring) | Esse agente é responsável pela lógica principal de geração e pontuação de imagens. Para isso, ele executa uma sequência de três subagentes. | image_generation_prompt_agent |
checker_agent_instance (subagente de image_scoring) | Esse agente verifica se o processo de pontuação de imagens deve continuar ou ser encerrado. Ele usa a ferramenta check_tool_condition para avaliar a condição de encerramento. | - |
checker_agent_instance (subagente de image_scoring) | Esse agente é especialista em criar comandos para geração de imagens. Ele recebe um texto de entrada e gera um comando detalhado adequado para o modelo de geração de imagens. | - |
image_generation_prompt_agent (subagente de image_generation_scoring_agent) | Esse agente é especialista em criar comandos para geração de imagens. Ele recebe um texto de entrada e gera um comando detalhado adequado para o modelo de geração de imagens. | - |
scoring_images_prompt (subagente de image_generation_scoring_agent): | Esse agente é especialista em avaliar e pontuar imagens com base em vários critérios. Ele pega a imagem gerada e atribui uma pontuação a ela. | - |
Lista de todas as ferramentas usadas
Ferramenta | Descrição | User agent |
check_tool_condition | Essa ferramenta verifica se a condição de término do loop foi atendida ou se o número máximo de iterações foi atingido. Se uma delas for verdadeira, o loop será interrompido. | checker_agent_instance |
generate_images | Essa ferramenta gera imagens usando o modelo Imagen 3. Ele também pode salvar as imagens geradas em um bucket do Cloud Storage. | image_generation_agent |
get_policy | Essa ferramenta busca uma política em um arquivo JSON. A política é usada pelo image_generation_prompt_agent para criar o comando de geração de imagens e pelo scoring_images_prompt para classificar as imagens. | image_generation_agent |
get_image | Essa ferramenta carrega o artefato de imagem gerado para que ele possa ser pontuado. | scoring_images_prompt |
set_score | Essa ferramenta define a pontuação total da imagem gerada no estado da sessão. | scoring_images_prompt |
7. instalar o ADK e configurar o ambiente
Neste exercício prático, vamos usar o Cloud Shell para realizar as tarefas.
Prepare uma guia do editor do Cloud Shell
- Clique neste link para acessar diretamente o editor do Cloud Shell.
- Clique em Continuar.
- Se for preciso autorizar o Cloud Shell, clique em Autorizar.
- Durante o restante deste laboratório, você pode trabalhar nesta janela como seu ambiente de desenvolvimento integrado (IDE) com o editor do Cloud Shell e o terminal do Cloud Shell.
- Abra um novo terminal usando Terminal>Novo terminal no editor do Cloud Shell. Todos os comandos abaixo serão executados neste terminal.
Baixe e instale o ADK e os exemplos de código para este laboratório
- Execute os comandos a seguir para clonar a origem necessária do GitHub e instalar as bibliotecas necessárias. Execute os comandos no terminal aberto no Editor do Cloud Shell.
#create the project directory
mkdir ~/imagescoring
cd ~/imagescoring
#clone the code in the local directory
git clone https://github.com/haren-bh/multiagenthandson.git
- Vamos usar o uv para criar o ambiente Python. Execute no terminal do editor do Cloud Shell:
#Install uv if you do not have installed yet
pip install uv
#Create the virtual environment
uv venv .adkvenv
source .adkvenv/bin/activate
#go to the project directory
cd ~/imagescoring/multiagenthandson
#install dependencies
uv pip install -r pyproject.toml
- Se você não tiver um bucket do Cloud Storage, crie um em Google Cloud Storage. Também é possível criar o bucket usando o comando gsutil. Conceda ao Agent Engine acesso ao Google Cloud Storage (execute no terminal do editor do Cloud Shell).
# First, make sure your PROJECT_ID variable is set
PROJECT_ID=$(gcloud config get-value project)
# Now, create the bucket with a unique name
# We'll use the project ID to help ensure uniqueness
gsutil mb gs://${PROJECT_ID}-imagescoring-bucket
#Now lets give Agent Engine the permission to access Cloud Storage
# 1. Get the current Project ID (text) and Project Number (numeric)
PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
# 2. Construct the Reasoning Engine Service Account email
SA_EMAIL="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
# 3. Create Agent Engine Service account if not already created
gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_NUMBER}
# 3. Grant GCS Access
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/storage.objectUser" --condition=None
- No editor, acesse "Visualizar" > "Ativar/desativar arquivos ocultos". Na pasta image_scoring, crie um arquivo .env com o seguinte conteúdo. Adicione os detalhes necessários, como o nome do projeto e o bucket do Cloud Storage (execute no terminal do editor do Cloud Shell).
#go to image_scoring folder
cd ~/imagescoring/multiagenthandson/image_scoring
cat <<EOF>> .env
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_CLOUD_STORAGE_BUCKET=$(gcloud config get-value project)-imagescoring-bucket
GCS_BUCKET_NAME=$(gcloud config get-value project)-imagescoring-bucket
SCORE_THRESHOLD=40
IMAGEN_MODEL="imagen-3.0-generate-002"
GENAI_MODEL="gemini-2.5-flash"
EOF
- Confira a estrutura do agente no código-fonte, começando por agent.py . Esse agente contém o agente raiz que se conecta aos outros agentes.
- Volte ao diretório principal multiagenthandson no terminal e execute o comando a seguir para executar o agente localmente (executar no terminal do Editor do Cloud Shell).
#go to the directory multiagenthandson
cd ~/imagescoring/multiagenthandson
# Run the following command to run agents locally
adk web
Figura 4
Pressione Ctrl+Clique (CMD+Clique para MacOS) no URL http:// exibido no terminal para abrir o cliente GUI baseado em navegador do ADK. Ele vai ficar parecido com a Figura 2
- Selecione image_scoring no menu suspenso no canto superior esquerdo (consulte a Figura 5). Agora vamos gerar algumas imagens! Você também deve encontrar as imagens no bucket do Cloud Storage. Tente os comandos a seguir ou crie os seus próprios.
- Uma paisagem de montanha tranquila ao pôr do sol
- Um gato andando de bicicleta
Figura 5: exemplo de saída
8. Implantar no Agent Engine
Agora vamos implantar o agente no Agent Engine. O Agent Engine é um serviço totalmente gerenciado para implantação de agentes no GCP. O Agent Engine é compatível com o ADK (Kit de Desenvolvimento de Agente). Assim, os agentes criados com o ADK (Kit de Desenvolvimento de Agente) podem ser implantados no Agent Engine.
- Crie o arquivo requirements.txt usando o Poetry. O Poetry vai usar pyproject.toml para criar o arquivo requirements.txt. Depois de executar o comando, verifique se o arquivo requirements.txt foi criado (execute no terminal do editor do Cloud Shell).
# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson
# install poetry-plugin-export
uv pip install poetry-plugin-export
#Create requirements.txt file
python3 -m poetry export -f requirements.txt --output requirements.txt --without-hashes
- Crie o pacote. Precisamos agrupar nosso app em um pacote Python .whl. Vamos usar o Poetry para isso. Depois de executar o comando, verifique se uma pasta "dist" foi criada e se ela contém o arquivo .whl (execute no terminal do editor do Cloud Shell).
# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson
#Create python package, to create whl file
python3 -m poetry build
- Agora vamos preparar o script de implantação. O script de implantação vai implantar nosso agente de pontuação de imagens ou o serviço do mecanismo de agente. Confirme o conteúdo de deploy.py na pasta deploy, conforme abaixo. Use o painel lateral do editor do Cloud Shell para encontrar o arquivo.
import vertexai
from image_scoring.agent import root_agent
import os
import glob # To easily find the wheel file
from dotenv import load_dotenv
# Load environment variables from image_scoring/.env
env_path = os.path.join(os.path.dirname(__file__), "..", "image_scoring", ".env")
load_dotenv(env_path)
PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.getenv("GOOGLE_CLOUD_LOCATION", "us-central1")
STAGING_BUCKET = f"gs://{os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}"
from vertexai import agent_engines
client=vertexai.Client(
project=PROJECT_ID,
location=LOCATION,
)
remote_app = client.agent_engines.create(
agent=root_agent,
config={
"display_name": "image-scoring",
"staging_bucket": STAGING_BUCKET,
"requirements": open(os.path.join(os.getcwd(), "requirements.txt")).readlines() + ["./dist/image_scoring-0.1.0-py3-none-any.whl"],
"extra_packages": [
"./dist/image_scoring-0.1.0-py3-none-any.whl",
], "env_vars":{"GCS_BUCKET_NAME":os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}
}
)
print(f"DEBUG: AgentEngine attributes: {dir(remote_app)}")
try:
print(remote_app.api_resource.name)
except AttributeError:
print("Could not find resource_name, check DEBUG output above.")
- Agora podemos executar o script de implantação. Primeiro, acesse a pasta principal multiagenthandson (executar no terminal do editor do Cloud Shell).
#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson
#run deploy script from the parent folder containing deploy.py
python3 -m deploy.deploy
Depois da implantação, você vai ver algo como abaixo, 
Figura 6: exemplo de saída
- Agora vamos testar o agente implantado. Para testar o mecanismo do agente implantado remotamente, primeiro copie o local do agente da saída de implantação no terminal. Ele será semelhante a este: projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680 .
Acesse a pasta testclient,abra o arquivo remote_test.py no editor do Cloud Shell e edite as seguintes linhas.
REASONING_ENGINE_ID = "projects/xxx/locations/us-central1/reasoningEngines/xxx" # TODO: Change this
- Na pasta principal multiagenthandson, execute o seguinte comando. Você vai receber uma saída como na Figura 4. Quando a execução for concluída, você poderá ver (Executar no terminal do editor do Cloud Shell).
#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson
#execute remote_test.py
python3 -m testclient.remote_test
Figura 7: exemplo de saída
9. Criar um agente A2A
Nesta etapa, vamos criar um agente A2A simples com base no agente criado nas etapas anteriores. Os agentes do ADK (Kit de Desenvolvimento de Agente) podem ser publicados no protocolo A2A. Estes são os principais pontos que você vai aprender nesta etapa.
- Conheça os conceitos básicos do protocolo A2A.
- Saiba como os protocolos ADK e A2A funcionam juntos.
- Saiba como interagir com o protocolo A2A.
Neste exercício prático, vamos usar o código na pasta image_scoring_adk_a2a_server. Antes de iniciar a tarefa, mude o diretório para esta pasta (executar no terminal do editor do Cloud Shell).
#change directory to image_scoring_adk_a2a_server
cd ~/imagescoring/multiagenthandson/image_scoring_adk_a2a_server
#copy the env file
cp ~/imagescoring/multiagenthandson/image_scoring/.env remote_a2a/image_scoring
1. Criar cartão do agente A2A
O protocolo A2A exige um card do agente que contenha todas as informações sobre ele, como recursos, guia de uso etc. Depois que um agente A2A é implantado, o card pode ser acessado usando o link .well-known/agent-card.json. Os clientes podem consultar essas informações para enviar a solicitação aos agentes.
Na pasta remote_a2a/image_scoring, confirme se há um arquivo agents.json usando o editor do Cloud Shell com o seguinte conteúdo.
{
"name": "image_scoring",
"description": "Agent that generates images based on user prompts and scores their adherence to the prompt.",
"url": "http://localhost:8001/a2a/image_scoring",
"version": "1.0.0",
"defaultInputModes": ["text/plain"],
"defaultOutputModes": ["image/png", "text/plain"],
"capabilities": {
"streaming": true,
"functions": true
},
"skills": [
{
"id": "generate_and_score_image",
"name": "Generate and Score Image",
"description": "Generates an image from a given text prompt and then evaluates how well the generated image adheres to the original prompt, providing a score.",
"tags": ["image generation", "image scoring", "evaluation", "AI art"],
"examples": [
"Generate an image of a futuristic city at sunset",
"Create an image of a cat playing a piano",
"Show me an image of a serene forest with a hidden waterfall"
]
}
]
}
2. Criar agente A2A
Na pasta raiz image_scoring_adk_a2a_server, confirme se há um arquivo a2a_agent.py usando o painel lateral do editor do Cloud Shell, que é o ponto de entrada do agente A2A. Ele precisa ter o seguinte conteúdo:
from google.adk.agents.remote_a2a_agent import RemoteA2aAgent
root_agent = RemoteA2aAgent(
name="image_scoring",
description="Agent to give interesting facts.",
agent_card="http://localhost:8001/a2a/image_scoring/.well-known/agent.json",
# Optional configurations
timeout=300.0, # HTTP timeout (seconds)
httpx_client=None, # Custom HTTP client
)
3. Executar o agente A2A
Agora podemos executar o agente. Para executar o agente, execute o seguinte comando na pasta principal image_scoring_adk_a2a_server (executar no terminal do Editor do Cloud Shell).
#following command runs the ADK agent as a2a agent
adk api_server --a2a --port 8001 remote_a2a
4. Testar o agente A2A
Depois que o agente estiver em execução, podemos testá-lo. Primeiro, vamos verificar o card do agente. Abra um novo terminal usando Terminal> Novo terminal e execute o seguinte comando (execute no terminal do Editor do Cloud Shell recém-aberto).
#Execute the following
curl http://localhost:8001/a2a/image_scoring/.well-known/agent.json
A execução do comando acima mostra o card do agente A2A, que é principalmente o conteúdo de agent.json criado na etapa anterior.
Agora vamos enviar uma solicitação ao agente. Podemos usar o curl para enviar uma solicitação ao agente (execute no terminal do editor do Cloud Shell recém-aberto).
curl -X POST http://localhost:8001/a2a/image_scoring -H 'Content-Type: application/json' -d '{
"id": "uuid-123",
"params": {
"message": {
"messageId": "msg-456",
"parts": [{"text": "Create an image of a cat"}],
"role": "user"
}
}
}'
Na solicitação acima, você pode mudar o comando alterando a linha "Crie uma imagem de um gato". Depois de executar o comando, verifique a imagem de saída no google cloud storage especificado.
10. Limpar
Agora vamos limpar o que acabamos de criar.
- Exclua o servidor do Vertex AI Agent Engine que acabamos de criar. Acesse a Vertex AI digitando "Vertex AI" na barra de pesquisa do console do Google Cloud. Clique em Mecanismo de agente no lado esquerdo.Para excluir o agente, clique em "Excluir".
Figura 8
- Excluir os arquivos no Cloud Shell
#Execute the following to delete the files
cd ~
rm -R ~/imagescoring
- Exclua o bucket. Acesse o console do GCP -> Cloud Storage , selecione e exclua seu bucket.
Figura 9: exclusão do bucket
11. Conclusão
Parabéns! Você implantou um aplicativo multiagente do ADK (Kit de Desenvolvimento de Agente) no Vertex AI Agent Engine. Essa é uma conquista significativa que abrange o ciclo de vida principal de um aplicativo moderno nativo da nuvem, oferecendo uma base sólida para implantar seus próprios sistemas de agentes complexos.
Resumo
Neste laboratório, você aprendeu a:
- Criar um aplicativo multiagente usando o ADK (Kit de Desenvolvimento de Agente)
- Implante o aplicativo no Vertex AI Agent Engine
- Crie um agente que possa se comunicar usando o protocolo A2A.
Recursos úteis