Criar um catálogo de e-commerce inteligente com persistência de vários bancos de dados

1. Introdução

No varejo moderno, seus dados são um ecossistema diverso e em expansão. Você tem dados transacionais confiáveis (preços e inventário), catálogos polimórficos "confusos" (especificações de eletrônicos x tamanhos de roupas) e petabytes de registros comportamentais. Forçar tudo isso em um único monólito não apenas cria dívida técnica, mas também destrói a experiência do usuário.

Neste codelab, você vai arquitetar uma potência poliglota que harmoniza:

  • AlloyDB: sua base transacional para consistência de alta velocidade e embeddings de imagem.
  • MongoDB Atlas no Google Cloud: sua camada de catálogo flexível e independente de esquema.
  • Cloud Storage: seu cérebro analítico para previsão de tendências em tempo real.
  • BigQuery: seu data warehouse digital de alta resolução.

O "tempero secreto"? Você vai usar o MCP Toolbox for Databases para orquestrar e unificar de forma inteligente as fontes de dados em execução no Cloud Run como uma ponte semântica. Depois, vai implantar um app de chat multiagente usando o Kit de Desenvolvimento de Agente (ADK). Você não está apenas criando uma barra de pesquisa, mas sim um cérebro inteligente para o varejo que entende o contexto, respeita as restrições e preenche a lacuna entre os dados brutos e a intenção humana.

A consulta impossível do usuário

Os agentes de e-commerce padrão falham no raciocínio multidimensional (combinando restrições negativas, semelhança visual e inventário em tempo real). Por exemplo, geralmente quero falar com um site de varejo assim:

"Oi, estou planejando uma viagem para tirar fotos em alta altitude. Mostre algumas mochilas resistentes ao clima com estilo semelhante ao da AeroGlow Pro, mas sem componentes de couro. Além disso, me diga se eles estão em estoque e se outros fotógrafos reclamaram da durabilidade da alça nas avaliações."

Por que essa consulta é "The Agent Killer":

  • Semelhança visual (AlloyDB + Pesquisa Vetorial): "Estilo semelhante ao AeroGlow Pro" requer comparação de embedding de imagem.
  • Restrição negativa (MongoDB): "Sem couro" exige a filtragem de atributos flexíveis e aninhados que geralmente não estão em um esquema SQL padrão.
  • Inventário em tempo real (AlloyDB): para saber se um item está "realmente em estoque", é preciso fazer uma verificação transacional em tempo real, não uma consulta em um índice da Pesquisa desatualizado.
  • Síntese semântica (BigQuery + multiagente): para analisar as avaliações sobre a "durabilidade da pulseira", o agente precisa resumir o feedback não estruturado do BigQuery em tempo real.

A maioria dos bots de varejo só veria "mochila" e "couro" e mostraria 10 mochilas de couro. Como estamos impedindo isso?

Porque não estamos apenas fazendo a correspondência de palavras-chave. Estamos usando o MCP Toolbox para permitir que nossos agentes "raciocinem" em todas essas fontes, a verdade transacional no AlloyDB e os atributos flexíveis no MongoDB simultaneamente. Vamos criar!

Atividades deste laboratório

Arquitetura de vários bancos de dados de e-commerce

Pré-requisitos

2. Antes de começar

Criar um projeto do Google Cloud

  1. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto na nuvem do Google Cloud.
  2. Verifique se o faturamento está ativado para seu projeto do Cloud. Saiba como verificar se o faturamento está ativado em um projeto.

Iniciar o Cloud Shell

O Cloud Shell é um ambiente de linha de comando executado no Google Cloud que vem pré-carregado com as ferramentas necessárias.

  1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.
  2. Depois de se conectar ao Cloud Shell, verifique sua autenticação:
    gcloud auth list
  3. Confirme se o projeto está configurado:
    gcloud config get project
  4. Se o projeto não estiver definido como esperado, defina-o:
    export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

definir variáveis

No Cloud Shell, defina as variáveis de ambiente para o ID e o número do projeto:

export PROJECT_ID=$(gcloud config get-value project)
export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

Ativar APIs obrigatórias

Execute este comando para ativar todas as APIs necessárias:

gcloud services enable \
  alloydb.googleapis.com \
  bigquery.googleapis.com \
  storage.googleapis.com \
  run.googleapis.com \
  cloudbuild.googleapis.com \
  artifactregistry.googleapis.com \
  iam.googleapis.com \
  secretmanager.googleapis.com \
  compute.googleapis.com \
  servicenetworking.googleapis.com \
  aiplatform.googleapis.com

3. Configurar o Cloud Storage

O Cloud Storage serve como um repositório enorme para recursos de mídia não estruturados, como imagens de produtos.

  1. No console do Google Cloud, acesse o Cloud Storage e clique em Criar bucket.
  2. Dê um nome globalmente exclusivo ao bucket, por exemplo, -ecommerce-images.
  3. Clique em Criar.
  4. Para permitir que o aplicativo de demonstração acesse as imagens sem autenticação, desmarque a opção Aplicar a prevenção do acesso público neste bucket e clique em Confirmar.
  5. Acesse a guia Permissões.
  6. Em Permissões, clique em Conceder acesso.
  7. Em Novos principais, digite allUsers.
  8. Em Selecionar papel, selecione Cloud Storage > Leitor de objetos do Storage.
  9. Clique em Salvar e em Permitir acesso público para confirmar que você está tornando o recurso público.
  10. No Cloud Shell, salve o nome do bucket em uma variável:
    export BUCKET=<your-bucket-name>
    Substitua pelo nome do bucket que você criou.

Fazer upload de imagens marcadoras de posição

O projeto usa imagens marcadoras de posição para oferecer a melhor experiência visual.

  1. No Cloud Shell, clone o repositório:
    git clone https://github.com/AbiramiSukumaran/polyglot-persist-ecommerce.git
  2. Navegue até a pasta UploadImages:
    cd polyglot-persist-ecommerce/UploadImages
  3. Faça upload das imagens de amostra para o bucket:
    gcloud storage cp *.jpg gs://$BUCKET/

4. Configurar o AlloyDB

O AlloyDB serve como a única fonte de verdade para dados estruturados, transacionais e críticos, como IDs de produtos, nomes, SKUs, preços e inventário. O AlloyDB também oferece ao agente de IA recursos de pesquisa por similaridade para recomendações e consultas em linguagem natural.

Provisionar um cluster do AlloyDB

  1. No console do Google Cloud, acesse AlloyDB para PostgreSQL.
  2. Clique em Criar cluster.
  3. Em ID do cluster, digite ecommerce-cluster.
  4. Defina uma senha forte para o usuário postgres. Para fins de aprendizado, use alloydb.
  5. Em Versão do banco de dados, mantenha o padrão.
  6. Em Região, selecione us-central1 (ou a região de sua preferência).

Configurar instância principal

  1. Em ID da instância, insira ecommerce-cluster-primary.
  2. Em Disponibilidade por zona, selecione Zona única.
  3. Em Série de máquinas, selecione N2 e, em Tipo de máquina, selecione 4 vCPU, 32 GB.
  4. Em Conectividade de IP privado, selecione Acesso a serviços particulares (PSA) e escolha a rede default.Se a rede padrão ainda não estiver definida, clique em Confirmar configuração de rede para criar uma.
  5. Em Conectividade de IP público, marque a caixa de seleção Ativar IP público para que a caixa de ferramentas do MCP se conecte corretamente neste codelab. O console ativa automaticamente a flag password.enforce_complexity, que o AlloyDB exige para o IP público.
  6. Em Redes externas autorizadas, insira 0.0.0.0/0. Marque a caixa de seleção Aceito os riscos e clique em Salvar.
  7. Clique em Criar cluster.

Inicializar o banco de dados

  1. Clique em AlloyDB Studio no menu de navegação à esquerda.
  2. No menu suspenso Banco de dados, selecione postgres.
  3. Selecione Autenticação integrada para fazer login no banco de dados.
  4. Em Nome de usuário, use o usuário postgres.
  5. Em Senha, digite a senha que você definiu anteriormente.
  6. Clique em Autenticar.
  7. Na visualização do editor, abra uma nova guia de consulta sem título.
  8. Copie a seguinte DDL e clique em Executar:
    CREATE TABLE products_core_table (
  product_id UUID PRIMARY KEY,
  name VARCHAR(255) NOT NULL,
  sku VARCHAR(50) UNIQUE NOT NULL,
  price NUMERIC(10, 2) NOT NULL,
  stock INT NOT NULL
);
  9. No Cloud Shell, acesse a pasta raiz do projeto:
    cd ~/polyglot-persist-ecommerce
  10. Abra o arquivo alloydb_insert_queries.sql no Cloud Shell e copie as consultas de inserção.
    cat alloydb_insert_queries.sql
  11. Em uma nova guia de consulta sem título, cole apenas as instruções INSERT e clique em Executar.
  12. Em uma nova guia de consulta sem título, copie a seguinte DDL e clique em Executar para criar um índice na tabela products_core_table:
    CREATE INDEX idx_products_core_sku ON products_core_table(sku);

Criar embeddings de imagem para o agente de IA buscar produtos semelhantes

A integração do agente de IA usa embeddings de imagem para buscar produtos semelhantes. Os embeddings são gerados usando o modelo multimodalembedding@001 e armazenados no banco de dados do AlloyDB. Os embeddings são vetores dimensionais de 1408 e são armazenados na coluna img_embeddings.

Antes de gerar embeddings, precisamos conceder os papéis necessários à conta de serviço do AlloyDB para acessar o Cloud Storage.

Conceder papéis à conta de serviço do AlloyDB para acessar o Cloud Storage

Conceda à conta de serviço do AlloyDB os papéis necessários para ler imagens do Cloud Storage e gerar embeddings da Vertex AI:

for role in roles/storage.objectUser roles/storage.objectViewer roles/aiplatform.user; do
  gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:service-${PROJECT_NUMBER}@gcp-sa-alloydb.iam.gserviceaccount.com" \
    --role=$role --condition=None
done

Ativar extensões

Para criar esse app, vamos usar as extensões pgvector e google_ml_integration. A extensão pgvector permite armazenar e pesquisar embeddings de vetor. A extensão google_ml_integration fornece funções que você usa para acessar endpoints de previsão da Vertex AI e receber previsões em SQL. Ative essas extensões executando as seguintes DDLs:

  1. No console do Google Cloud, acesse AlloyDB para PostgreSQL.
  2. Clique em AlloyDB Studio no menu de navegação à esquerda.
  3. Na visualização do editor, abra uma nova guia de consulta sem título.
  4. Copie a seguinte DDL e clique em Executar:
    CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

Inicializar o banco de dados com embeddings

  1. Adicione a coluna img_embeddings ao products_core_table.
    ALTER TABLE products_core_table
ADD COLUMN img_embeddings vector(1408);
  2. Imprima a consulta de embeddings com o nome do bucket preenchido:
    cd ~/polyglot-persist-ecommerce
sed "s/<STORAGE_BUCKET_NAME>/$BUCKET/g" alloydb_generate_embeddings.sql
  3. Copie a saída, cole em uma nova guia de consulta do AlloyDB Studio e clique em Executar. Isso leva cerca de um minuto. Se o tempo limite for atingido, execute-o novamente. Os produtos que já têm embeddings serão ignorados.

5. Configurar o MongoDB Atlas no Google Cloud

O MongoDB armazena detalhes de produtos semiestruturados e dados flexíveis de comportamento do usuário (como cliques e visualizações).

Criar cluster do MongoDB

  1. Faça login no MongoDB Atlas (crie uma conta sem custo financeiro, se necessário).
  2. Em Implantar o cluster, selecione Sem custo financeiro. O Atlas pré-seleciona um nível pago. Verifique se a opção "Free" está selecionada.
  3. Em Provedor, selecione Google Cloud e, em Região, selecione Iowa (us-central1).
  4. Em Nome, insira ecommerce-cluster e desmarque Pré-carregar conjunto de dados de amostra.
  5. Clique em Criar implantação.

Permitir acesso e criar um usuário de banco de dados

O Atlas abre a caixa de diálogo Connect to ecommerce-cluster.

  1. Clique em Adicionar um endereço IP diferente, insira 0.0.0.0/0 e adicione-o.
  2. Digite store-user em Nome de usuário e storeuser em Senha. Depois, clique em Criar usuário do banco de dados.
  3. Clique em Escolher um método de conexão e em Drivers e bibliotecas de cliente.
  4. Em Usar esta string de conexão no aplicativo, copie a string de conexão. O caminho é parecido com mongodb+srv://store-user:@ecommerce-cluster.xxxxx.mongodb.net/. Substitua por storeuser e salve a string. Você vai usá-la em tools.yaml.

Criar banco de dados e coleção

  1. No painel de navegação à esquerda, clique em Explorador de dados, em Criar banco de dados e insira os detalhes:
    • Nome do banco de dados : ecommerce_db
    • Nome da coleção : product_details_collection
  2. Clique em Criar banco de dados.
  3. No Data Explorer, selecione o nome da coleção.
  4. Clique no ícone Adicionar dados (+) e em Inserir documento.
  5. Copie o conteúdo JSON de product_details_export.json e cole-o na caixa de diálogo do editor Insert Document.
  6. O Atlas mostra um banner oferecendo a conversão do texto para a sintaxe do shell. Clique em CONVERTER e em Inserir. Verifique se 192 documentos foram adicionados.
  7. No Data Explorer, clique em Criar coleção (+) ao lado do banco de dados ecommerce_db.
  8. Digite user_interactions_collection como nome da coleção e clique em Criar coleção.
  9. No Data Explorer, selecione a coleção user_interactions_collection.
  10. Clique no ícone Adicionar dados (+) e em Inserir documento.
  11. Copie o conteúdo JSON de user_interactions_export.json e cole-o na caixa de diálogo do editor Inserir documento.
  12. O Atlas mostra um banner oferecendo a conversão do texto para a sintaxe do shell. Clique em CONVERTER e em Inserir. Verifique se 211 documentos foram adicionados.

6. Configurar o BigQuery

O BigQuery agrega e analisa o histórico de comportamento do usuário para gerar relatórios e recomendações inteligentes.

Criar o conjunto de dados

  1. No console do Google Cloud, acesse o BigQuery.
  2. Ao lado do ID do projeto no painel "Explorador", clique no menu de três pontos e selecione Criar conjunto de dados.
  3. Insira ecommerce_analytics em ID do conjunto de dados.
  4. Em Local dos dados, selecione US (multiple regions) (a configuração tools.yaml espera o local US).
  5. Clique em Criar conjunto de dados.

Criar a tabela do Analytics

  1. Abra uma nova consulta no espaço de trabalho do BigQuery.
  2. Execute a seguinte instrução SQL para criar a tabela de resumo que vincula os usuários associados às interações com os produtos:
CREATE TABLE ecommerce_analytics.user_product_interactions (
    user_id STRING DEFAULT 'any user',
    product_id STRING,
    interaction_score INT
);

Conceder papéis à conta de serviço do Compute

Conceda à conta de serviço padrão do Compute os papéis necessários para o MCP Toolbox e o app:

for role in \
  roles/bigquery.dataEditor \
  roles/bigquery.jobUser \
  roles/secretmanager.secretAccessor \
  roles/alloydb.client \
  roles/serviceusage.serviceUsageConsumer \
  roles/storage.objectViewer \
  roles/aiplatform.user \
  roles/artifactregistry.writer; do
  gcloud projects add-iam-policy-binding $PROJECT_ID \
    --member="serviceAccount:${PROJECT_NUMBER}-compute@developer.gserviceaccount.com" \
    --role="$role" \
    --condition=None
done

Como alternativa, no console, acesse IAM e administrador > IAM, clique em Conceder acesso, insira a conta de serviço e adicione os mesmos papéis.

7. Entender o aplicativo de ponta a ponta

Para entender como cada componente funciona com os outros, vamos criar um aplicativo de e-commerce que usa vários bancos de dados e serviços. O aplicativo é criado com um back-end em Python (Flask) e integra vários serviços e bancos de dados do Google Cloud.

Entender a estrutura de diretórios

Na próxima seção, você vai clonar o repositório polyglot-persist-ecommerce e usá-lo para executar o aplicativo localmente. Depois de testar o aplicativo localmente, vamos implantar o MCP Toolbox e o aplicativo no Cloud Run.

Confira os arquivos baixados nesse diretório. Os seguintes diretórios de alto nível estão presentes:

  • UploadImages: armazena recursos de imagem, usados principalmente para documentação ou conteúdo visual do catálogo de produtos de e-commerce.
  • static: armazena os recursos estáticos da Web do aplicativo, como arquivos CSS e JavaScript, usados para estilizar e adicionar interatividade à interface do usuário ( fonte).
  • templates: armazena os modelos HTML (provavelmente Jinja2 para Flask) usados pelo aplicativo Python para renderizar dinamicamente páginas da Web para o catálogo de e-commerce ( fonte).

Os arquivos neste repositório trabalham juntos para criar, configurar e implantar um aplicativo de e-commerce multidb. Arquivos centrais como app.py orquestram o back-end integrando diversas fontes de dados definidas em arquivos SQL e JSON, enquanto os arquivos de configuração garantem uma implantação perfeita em ambientes de nuvem:

  • app.py: orquestra o back-end do Flask e as integrações com vários bancos de dados.
  • agentengine.py: lógica principal para inicializar e configurar agentes de IA da Vertex AI.
  • .env: armazena secrets para conexões de banco de dados e armazenamento.
  • tools.yaml: configura o MCP Toolbox para operações de banco de dados multidb.
  • Dockerfile: define a imagem do contêiner e a configuração do ambiente.
  • requirements.txt: lista as bibliotecas do Python necessárias para o ambiente de execução do aplicativo.
  • tools.yaml: configurações do MCP Toolbox.
  • Procfile: especifica comandos de execução de produção para implantação.
  • alloydb_insert_queries.sql: contém consultas SQL para dados relacionais.
  • product_details_export.json e user_interactions_export.json: fornecem dados JSON de amostra para o banco de dados NoSQL.
  • README.md: orienta a configuração, a implantação e o entendimento do projeto.

Fluxo de ponta a ponta do aplicativo

  • Configuração do AlloyDB: provisione um cluster de alto desempenho e use os scripts SQL fornecidos para criar a products_core_table com colunas de vetor para embeddings de imagem.
  • Configuração do MongoDB Atlas: implante um cluster no Google Cloud para armazenar atributos de produtos fluidos em product_details e registrar clickstreams em tempo real em user_interactions.
  • Análise do BigQuery: crie um conjunto de dados para agregar registros de interação, permitindo consultas analíticas complexas que identificam os cinco itens mais populares em milhões de eventos.
  • Repositório do Cloud Storage: crie um bucket público para armazenar imagens de produtos em alta resolução, garantindo que cada recurso seja acessível usando um URL assinado ou público para o front-end.
  • Implantação do MCP Toolbox: implante o Toolbox no Cloud Run, estabelecendo-o como a ponte RESTful central que traduz a intenção de linguagem natural em consultas de vários bancos de dados.
  • Configuração de Tools.yaml: defina suas "ferramentas", como get_product_core_data ou get_top_5_views, mapeando operações SQL e NoSQL específicas para nomes simples e legíveis para o agente.
  • Lógica de back-end do Flask: implemente rotas app.py que interagem com o MCP Toolbox, gerenciando a coordenação da recuperação de dados e servindo como a API para a interface.
  • Orquestração multiagente: configure os agentes do ADK no código para entender a intenção do usuário e selecionar a ferramenta certa para resolver consultas de varejo complexas e de várias fontes.
  • Integração de front-end: crie uma interface index.html com o catálogo de produtos e o recurso de gravação de interações, uma guia "Análise" para entender o desempenho dos produtos e uma guia "Agente" dedicada que usa o chat multiagente do ADK para oferecer uma experiência de compra conversacional integrada.

Agora, vamos implementar a orquestração e as implantações.

8. Configurar o MCP Toolbox e implantar no Cloud Run

A MCP Toolbox abstrai nossas várias fontes de dados, permitindo que o aplicativo busque e grave dados de maneira uniforme.

Instalar o MCP Toolbox localmente

Faça o download do binário da MCP Toolbox no diretório principal e torne-o executável:

export VERSION=1.15.0
curl -L -o ~/toolbox https://storage.googleapis.com/mcp-toolbox-for-databases/v$VERSION/linux/amd64/toolbox
chmod +x ~/toolbox

Configurar tools.yaml

Você precisa definir as abstrações para o AlloyDB, o MongoDB e o BigQuery. O arquivo tools.yaml informa à MCP Toolbox como interagir entre si.

  1. O repositório já inclui tools.yaml. Abra o arquivo:
    cd ~/polyglot-persist-ecommerce
cloudshell edit tools.yaml
  2. Substitua os marcadores de posição ***** pelos seus valores:

    Banco de dados

    Campo

    Valor de exemplo

    AlloyDB/BigQuery

    project

    YOUR_PROJECT_ID

    AlloyDB

    region

    us-central1

    AlloyDB

    cluster

    ecommerce-cluster

    AlloyDB

    instance

    ecommerce-cluster-primary

    AlloyDB

    database

    postgres

    AlloyDB

    password

    alloydb

    AlloyDB

    ipType

    public (adicione essa linha em alloydb-source se ela não estiver lá)

    MongoDB

    uri

    a string de conexão que você salvou anteriormente

  3. Aponte as prévias de imagem para seu bucket:
    sed -i "s/ecommerce-app-images/$BUCKET/g" tools.yaml

Testar a interface da ferramenta

  1. No terminal do Cloud Shell, execute a caixa de ferramentas localmente para disponibilizar a interface:
    ~/toolbox --config tools.yaml --ui --enable-api
  2. No Cloud Shell, clique em Visualização na Web > Alterar porta, insira 5000 e adicione /ui ao final do URL que será aberto.

A seguinte interface da MCP Toolbox é exibida:

Interface do MCP Toolbox

Quando terminar, pressione Ctrl+C para interromper a caixa de ferramentas local.

Implantar no Cloud Run

Implantar o MCP Toolbox no Cloud Run para disponibilizá-lo como um serviço gerenciado e seguro que nosso aplicativo pode usar para consultar os bancos de dados. Vamos armazenar a configuração no Secret Manager para proteger detalhes de conexão sensíveis.

  1. Faça upload da configuração tools.yaml para o Google Secret Manager:
    gcloud secrets create tools --data-file=tools.yaml
    Se você mudar tools.yaml mais tarde, faça upload de uma nova versão com:
    gcloud secrets versions add tools --data-file=tools.yaml
  2. Implante usando a imagem de contêiner pública do MCP Toolbox:
    gcloud run deploy toolbox \
    --image us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$VERSION \
    --region us-central1 \
    --service-account ${PROJECT_NUMBER}-compute@developer.gserviceaccount.com \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --args="--config=/app/tools.yaml","--address=0.0.0.0","--port=8080","--ui","--enable-api" \
    --allow-unauthenticated
    --enable-api ativa a API REST que o app da Web usa.
  3. Salve o URL da caixa de ferramentas:
    export TOOLBOX_URL=$(gcloud run services describe toolbox --region us-central1 --format='value(status.url)')
echo $TOOLBOX_URL
    Abra $TOOLBOX_URL/ui no navegador para ver as ferramentas.

9. Configurar o aplicativo de e-commerce e implantar no Cloud Run

Com os bancos de dados em execução e a abstração do MCP Toolbox implantada, podemos executar o aplicativo da Web do Flask.

Para disponibilizar o catálogo de produtos, o aplicativo Flask processa os dados seguindo estas etapas:

  1. Buscar dados principais: recupera a lista completa de produtos do AlloyDB (list_products_core).
  2. Buscar detalhes estendidos: recupera todos os detalhes do produto do MongoDB (list_all_product_details).
  3. Combinar listas: concatena as duas listas.
  4. Enriquecer com mídia: adiciona o URL da imagem do Cloud Storage a cada item.

Criar o Agent Engine

  1. Instale as dependências:
    cd ~/polyglot-persist-ecommerce
pip install -r requirements.txt
    Observação: essa etapa pode levar vários minutos para resolver e instalar pacotes.
  2. Inicialize e registre o agente de IA usando o mecanismo de raciocínio da Vertex AI:
    export REASONING_ENGINE_LOCATION=us-central1
export APP_NAME=$(python agentengine.py)
echo $APP_NAME
    A saída será semelhante a esta:
    projects/991742412753/locations/us-central1/reasoningEngines/4933254136889081856

O app lê as configurações das variáveis de ambiente, que são transmitidas no comando de implantação abaixo. Portanto, não é necessário editar .env.

Implantar o front-end no Cloud Run

  1. Implante o aplicativo da Web no Cloud Run para concluir a arquitetura:
    gcloud run deploy polyglot --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars="MCP_TOOLBOX_SERVER_URL=$TOOLBOX_URL,GCS_PRODUCT_BUCKET=$BUCKET,FALLBACK_IMAGE_URL=https://storage.googleapis.com/$BUCKET/fallback.jpg,GOOGLE_GENAI_USE_VERTEXAI=TRUE,PROJECT_ID=$PROJECT_ID,GOOGLE_CLOUD_LOCATION=global,REASONING_ENGINE_LOCATION=$REASONING_ENGINE_LOCATION,APP_NAME=$APP_NAME,MODEL=gemini-3.5-flash"

Seu aplicativo agora está ao vivo. Abra o URL do serviço fornecido pelo Cloud Run para ver o catálogo do Multidb Ecommerce. O URL será semelhante a https://polyglot-*********-uc.a.run.app/.

10. Conheça o aplicativo

  1. Clique em Catálogo de produtos para ver todos os produtos.
    Catálogo de produtos
  2. Clique no ícone de um produto para ver os detalhes do produto. As imagens são provenientes do Cloud Storage, os detalhes do produto são buscados no MongoDB e o inventário do produto é buscado no AlloyDB.Detalhes do produto
  3. Interaja com o catálogo de produtos para gerar visualizações e gravações simuladas enviadas ao MongoDB.
  4. Clique em ETL e análise para conferir as análises do produto. Você vai notar que as análises de produtos são buscadas no BigQuery.
    ETL e análise de produtos
  5. Clique na guia Agente de IA para interagir com o agente. Faça perguntas em linguagem natural, como as seguintes:
    I'm planning a high-altitude photography trip.
Show me some weather-resistant backpacks similar in style to aero glow pro
but without any leather components. Also, let me know if they are actually in
stock and if other photographers have complained about the strap durability
in the reviews.
    Agente de IA

A pesquisa retorna exatamente o que pedimos: uma mochila sem componentes de couro, em estoque e sem reclamações sobre a durabilidade das alças nas avaliações.

Agente de IA

11. Limpar

Para evitar cobranças contínuas na sua conta do Google Cloud, exclua os recursos criados durante este codelab.

Execute estes comandos do Cloud Shell:

gcloud run services delete toolbox --region us-central1 --quiet
gcloud run services delete polyglot --region us-central1 --quiet
gcloud secrets delete tools --quiet
bq rm -r -f -d $PROJECT_ID:ecommerce_analytics
gcloud storage rm --recursive gs://$BUCKET
gcloud alloydb clusters delete ecommerce-cluster --region us-central1 --force --quiet

Se quiser, exclua a instância do Agent Engine:

curl -X DELETE -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  "https://us-central1-aiplatform.googleapis.com/v1/$APP_NAME?force=true"

Como alternativa, no console do Google Cloud, acesse Vertex AI > Agent Engine e exclua a instância.

Opcionalmente, para excluir todo o projeto na nuvem do Google Cloud e todos os recursos dele, execute o seguinte comando:

gcloud projects delete $PROJECT_ID

12. Parabéns

Parabéns! Você criou uma arquitetura Multidb entre nuvens.

Você demonstrou como o MCP Toolbox serve como a cola arquitetônica para um aplicativo moderno e especializado. Ao escolher o banco de dados certo para cada trabalho, você conseguiu:

  • Gravações de dados flexíveis: MongoDB para log de eventos.
  • Consistência transacional: AlloyDB para integridade principal.
  • Análise de alto desempenho: BigQuery para business intelligence.
  • Desenvolvimento unificado: um único back-end em Python que abstrai toda a complexidade usando o MCP Toolbox.

Documentos de referência

Saiba mais sobre os produtos relacionados do Google Cloud e confira estes codelabs:

Para mais informações sobre os produtos usados neste codelab, consulte: