Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Créer un catalogue d'e-commerce intelligent avec persistance multidatabase

1. Introduction

Dans le commerce moderne, vos données constituent un écosystème vaste et diversifié. Vous disposez de données transactionnelles solides (tarifs et inventaire), de catalogues polymorphes "désordonnés" (spécifications électroniques par rapport aux tailles de vêtements) et de pétaoctets de journaux de comportement. Forcer ces éléments à s'intégrer dans un seul monolithe ne crée pas seulement une dette technique, cela nuit également à l'expérience utilisateur.

Dans cet atelier de programmation, vous allez concevoir une solution polyglotte qui harmonise :

AlloyDB : votre colonne vertébrale transactionnelle pour une cohérence à grande vitesse et des embeddings d'images.
MongoDB Atlas sur Google Cloud : votre couche de catalogue flexible et indépendante du schéma.
Cloud Storage : votre cerveau analytique pour prévoir les tendances en temps réel.
BigQuery : votre entrepôt numérique haute résolution.

L'ingrédient secret ? Vous utiliserez MCP Toolbox for Databases pour orchestrer et unifier intelligemment les sources de données exécutées sur Cloud Run en tant que pont sémantique, puis vous déploierez une application de chat multi-agents à l'aide d'Agent Development Kit (ADK). Vous ne créez pas seulement une barre de recherche, mais un cerveau intelligent pour le commerce, qui comprend le contexte, respecte les contraintes et comble l'écart entre les données brutes et l'intention humaine.

La requête utilisateur impossible

Les agents d'e-commerce standards échouent au raisonnement multidimensionnel (combinaison de contraintes négatives, de similarité visuelle et d'inventaire en temps réel). Par exemple, j'ai l'habitude de m'adresser à un site de vente au détail de la manière suivante :

"Salut, je prévois un voyage pour faire de la photographie en haute altitude. Montre-moi des sacs à dos résistants aux intempéries, d'un style similaire à l'AeroGlow Pro, mais sans aucun composant en cuir. Dis-moi aussi s'ils sont en stock et si d'autres photographes se sont plaints de la durabilité de la sangle dans les avis."

Pourquoi cette requête est-elle "The Agent Killer" ?

Similarité visuelle (AlloyDB + Vector Search) : "Style similaire à l'AeroGlow Pro" nécessite une comparaison des embeddings d'images.
Contrainte négative (MongoDB) : "Sans cuir" nécessite de filtrer des attributus flexibles et imbriqués qui ne se trouvent généralement pas dans un schéma SQL standard.
Inventaire en temps réel (AlloyDB) : pour savoir si un produit est réellement en stock, il faut effectuer une vérification transactionnelle en temps réel (et non pas utiliser un index de recherche obsolète).
Synthèse sémantique (BigQuery + multi-agent) : pour analyser les avis sur la "durabilité du bracelet", l'agent doit résumer à la volée les commentaires non structurés de BigQuery.

La plupart des bots de vente au détail ne verraient que "sac à dos" et "cuir", et afficheraient 10 sacs à dos en cuir. Comment l'empêcher ?

En effet, nous ne nous contentons pas de mettre en correspondance des mots clés. Nous utilisons MCP Toolbox pour permettre à nos agents de "raisonner" sur toutes ces sources, à savoir la vérité transactionnelle dans AlloyDB et les attributs flexibles dans MongoDB, simultanément. C'est parti !

Objectifs de l'atelier

Provisionner un cluster AlloyDB pour les données produit principales
Configurer MongoDB Atlas sur Google Cloud pour stocker des informations détaillées semi-structurées sur les produits
Créez un bucket Cloud Storage pour diffuser les images des produits.
Déployer MCP Toolbox for Databases sur Cloud Run pour un accès uniforme aux données
Exécuter des processus ETL pour transférer des données vers BigQuery à des fins d'analyse
Discutez avec un agent IA en langage naturel.

Architecture multi-base de données pour l'e-commerce

Prérequis

Un navigateur Web (par exemple, Chrome)
Un projet Google Cloud avec facturation activée
Un compte MongoDB Atlas sur Google Cloud sans frais

2. Avant de commencer

Créer un projet Google Cloud

Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Démarrer Cloud Shell

Cloud Shell est un environnement de ligne de commande exécuté dans Google Cloud et fourni avec les outils nécessaires.

Cliquez sur Activer Cloud Shell en haut de la console Google Cloud.
Une fois connecté à Cloud Shell, vérifiez votre authentification :
```
gcloud auth list
```
Vérifiez que votre projet est configuré :
```
gcloud config get project
```

Si votre projet n'est pas défini comme prévu, définissez-le :

export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

Définir les variables

Dans Cloud Shell, définissez les variables d'environnement pour l'ID et le numéro de votre projet :

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

Activer les API requises

Exécutez cette commande pour activer toutes les API requises :

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. Configurer Cloud Storage

Cloud Storage sert de stockage massif pour les composants multimédias non structurés, tels que les images de produits.

Dans la console Google Cloud, accédez à Cloud Storage, puis cliquez sur Créer un bucket.
Attribuez un nom unique à votre bucket, par exemple -ecommerce-images.
Cliquez sur Créer.
Pour autoriser l'application de démonstration à accéder aux images sans authentification, décochez l'option Appliquer la protection contre l'accès public sur ce bucket, puis cliquez sur Confirmer.
Accédez à l'onglet Autorisations.
Dans Autorisations, cliquez sur Accorder l'accès.
Dans Nouveaux comptes principaux, saisissez allUsers.
Dans le champ Sélectionnez un rôle, cliquez sur Cloud Storage > Lecteur d'objets Storage.
Cliquez sur Enregistrer, puis sur Autoriser l'accès public pour confirmer que vous rendez la ressource publique.
Dans Cloud Shell, enregistrez le nom du bucket dans une variable :
```
export BUCKET=<your-bucket-name>
```
Remplacez par le nom du bucket que vous avez créé.

Importer des images de substitution

Le projet utilise des images de substitution pour une expérience visuelle optimale.

Dans Cloud Shell, clonez le dépôt :

git clone https://github.com/AbiramiSukumaran/polyglot-persist-ecommerce.git

Accédez au dossier UploadImages :

cd polyglot-persist-ecommerce/UploadImages

Importez les exemples d'images dans votre bucket :
```
gcloud storage cp *.jpg gs://$BUCKET/
```

4. Configurer AlloyDB

AlloyDB sert de source unique de vérité pour les données structurées, transactionnelles et critiques telles que les ID produit, les noms, les SKU, les prix et l'inventaire. AlloyDB fournit également à l'agent IA des fonctionnalités de recherche par similarité pour les recommandations et les requêtes en langage naturel.

Provisionner un cluster AlloyDB

Dans la console Google Cloud, accédez à AlloyDB pour PostgreSQL.
Cliquez sur Créer un cluster.
Dans le champ ID de cluster, saisissez ecommerce-cluster.
Définissez un mot de passe sécurisé pour l'utilisateur postgres. À des fins d'apprentissage, vous pouvez utiliser alloydb.
Pour Version de la base de données, conservez la valeur par défaut.
Pour Région, sélectionnez us-central1 (ou la région de votre choix).

Configurer l'instance principale

Dans le champ ID d'instance, saisissez ecommerce-cluster-primary.
Dans Disponibilité zonale, sélectionnez Zone unique.
Pour Série de machines, sélectionnez N2, et pour Type de machine, sélectionnez 4 vCPU, 32 GB.
Dans Connectivité IP privée, sélectionnez Accès aux services privés (PSA), puis sélectionnez le réseau default.Si le réseau par défaut n'est pas déjà défini, cliquez sur Confirmer la configuration du réseau pour en créer un.
Dans Connectivité IP publique, cochez la case Activer l'adresse IP publique pour que la boîte à outils MCP se connecte correctement dans cet atelier de programmation. La console active automatiquement l'option password.enforce_complexity, requise par AlloyDB pour l'adresse IP publique.
Dans Réseaux externes autorisés, saisissez 0.0.0.0/0. Cochez la case Je reconnais les risques, puis cliquez sur Enregistrer.
Cliquez sur Créer un cluster.

Initialiser la base de données

Cliquez sur AlloyDB Studio dans le menu de navigation de gauche.
Dans le menu déroulant Base de données, sélectionnez postgres.
Sélectionnez Authentification intégrée pour vous connecter à la base de données.
Pour Nom d'utilisateur, utilisez l'utilisateur postgres.
Dans le champ Password (Mot de passe), saisissez le mot de passe que vous avez défini précédemment.
Cliquez sur Authentifier.
Dans la vue de l'éditeur, ouvrez un nouvel onglet "Requête sans titre".

Copiez le LDD suivant, puis cliquez sur Exécuter :

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

Dans Cloud Shell, accédez au dossier racine du projet :
```
cd ~/polyglot-persist-ecommerce
```
Ouvrez le fichier alloydb_insert_queries.sql dans Cloud Shell et copiez les requêtes d'insertion.
```
cat alloydb_insert_queries.sql
```
Dans un nouvel onglet de requête sans titre, collez uniquement les instructions INSERT, puis cliquez sur Exécuter.
Dans un nouvel onglet de requête sans titre, copiez le code LDD suivant et cliquez sur Exécuter pour créer un index sur la table products_core_table :
```
CREATE INDEX idx_products_core_sku ON products_core_table(sku);
```

Créer des embeddings d'images pour que l'agent IA récupère des produits similaires

L'intégration de l'agent IA utilise des embeddings d'images pour récupérer des produits similaires. Les embeddings sont générés à l'aide du modèle multimodalembedding@001 et stockés dans la base de données AlloyDB. Les embeddings sont des vecteurs à 1 408 dimensions et sont stockés dans la colonne img_embeddings.

Avant de pouvoir générer des embeddings, nous devons attribuer les rôles requis au compte de service AlloyDB pour accéder à Cloud Storage.

Attribuer des rôles au compte de service AlloyDB pour accéder à Cloud Storage

Attribuez au compte de service AlloyDB les rôles dont il a besoin pour lire les images depuis Cloud Storage et générer des embeddings 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

Activer les extensions

Pour créer cette application, nous utiliserons les extensions pgvector et google_ml_integration. L'extension pgvector vous permet de stocker et de rechercher des embeddings vectoriels. L'extension google_ml_integration fournit les fonctions que vous utilisez pour accéder aux points de terminaison de prédiction Vertex AI afin d'obtenir des prédictions en SQL. Activez ces extensions en exécutant les LDD suivants :

Dans la console Google Cloud, accédez à AlloyDB pour PostgreSQL.
Cliquez sur AlloyDB Studio dans le menu de navigation de gauche.
Dans la vue de l'éditeur, ouvrez un nouvel onglet "Requête sans titre".

Copiez le LDD suivant, puis cliquez sur Exécuter :

CREATE EXTENSION IF NOT EXISTS vector;
CREATE EXTENSION IF NOT EXISTS google_ml_integration;

Initialiser la base de données avec des embeddings

Ajoutez la colonne img_embeddings à products_core_table.

ALTER TABLE products_core_table
ADD COLUMN img_embeddings vector(1408);

Affichez la requête d'embeddings en indiquant le nom de votre bucket :

cd ~/polyglot-persist-ecommerce
sed "s/<STORAGE_BUCKET_NAME>/$BUCKET/g" alloydb_generate_embeddings.sql

Copiez le résultat, collez-le dans un nouvel onglet de requête AlloyDB Studio, puis cliquez sur Exécuter. Cela prend environ une minute. Si le délai d'expiration est dépassé, exécutez-la à nouveau. Les produits qui ont déjà des embeddings sont ignorés.
Le script ne traite que les produits qui ont une image dans UploadImages/.

5. Configurer MongoDB Atlas sur Google Cloud

MongoDB stocke des informations détaillées et semi-structurées sur les produits, ainsi que des données flexibles sur le comportement des utilisateurs (comme les clics et les vues).

Créer un cluster MongoDB

Connectez-vous à MongoDB Atlas (créez un compte sans frais si nécessaire).
Sur la page Deploy your cluster (Déployer votre cluster), sélectionnez Free (sans frais). (Atlas présélectionne un niveau payant. Assurez-vous que l'option "Free" est sélectionnée.)
Pour Fournisseur, sélectionnez Google Cloud, et pour Région, sélectionnez Iowa (us-central1).
Dans le champ Nom, saisissez ecommerce-cluster, puis décochez l'option Précharger l'exemple d'ensemble de données.
Cliquez sur Créer un déploiement.

Autoriser l'accès et créer un utilisateur de base de données

Atlas ouvre la boîte de dialogue Connect to ecommerce-cluster (Se connecter à ecommerce-cluster).

Cliquez sur Ajouter une autre adresse IP, saisissez 0.0.0.0/0, puis ajoutez-la.
L'utilisation de 0.0.0.0/0 permet l'accès depuis n'importe quelle adresse IP. Cette approche est acceptable pour une démonstration temporaire, mais en production, vous devez limiter l'accès à des plages d'adresses IP spécifiques.
Saisissez store-user dans le champ Nom d'utilisateur et storeuser dans le champ Mot de passe, puis cliquez sur Créer un utilisateur de base de données.
Cliquez sur Choisir une méthode de connexion, puis sur Pilotes et bibliothèques clientes.
Sous Utiliser cette chaîne de connexion dans votre application, copiez la chaîne de connexion. Il se présente comme suit : mongodb+srv://store-user:@ecommerce-cluster.xxxxx.mongodb.net/. Remplacez par storeuser et enregistrez la chaîne. Vous l'utiliserez dans tools.yaml.

Créer une base de données et une collection

Dans le menu de navigation de gauche, cliquez sur Explorateur de données, puis sur Créer une base de données et saisissez les informations suivantes :
- Nom de la base de données : ecommerce_db
- Nom de la collection : product_details_collection
Cliquez sur Créer une base de données.
Dans l'explorateur de données, sélectionnez le nom de la collection.
Cliquez sur l'icône Ajouter des données (+), puis sur Insérer un document.
Copiez le contenu JSON de product_details_export.json et collez-le dans la boîte de dialogue de l'éditeur Insérer un document.
Atlas affiche une bannière proposant de convertir le texte en syntaxe shell. Cliquez sur CONVERTIR, puis sur Insérer. Vérifiez que 192 documents ont été ajoutés.
Dans l'explorateur de données, cliquez sur Créer une collection (+) à côté de la base de données ecommerce_db.
Saisissez user_interactions_collection comme nom de collection, puis cliquez sur Créer une collection.
Dans l'explorateur de données, sélectionnez la collection user_interactions_collection.
Cliquez sur l'icône Ajouter des données (+), puis sur Insérer un document.
Copiez le contenu JSON de user_interactions_export.json et collez-le dans la boîte de dialogue de l'éditeur Insérer un document.
Atlas affiche une bannière proposant de convertir le texte en syntaxe shell. Cliquez sur CONVERTIR, puis sur Insérer. Vérifiez que 211 documents ont été ajoutés.

6. Configurer BigQuery

BigQuery agrège et analyse l'historique du comportement des utilisateurs pour générer des rapports et des recommandations intelligents.

Créer l'ensemble de données

Dans la console Google Cloud, accédez à BigQuery.
À côté de l'ID de votre projet dans le volet "Explorateur", cliquez sur le menu à trois points, puis sélectionnez Créer un ensemble de données.
Saisissez ecommerce_analytics pour l'ID de l'ensemble de données.
Pour Emplacement des données, sélectionnez US (multiple regions) (la configuration tools.yaml attend l'emplacement US).
Cliquez sur Créer un ensemble de données.

Créer la table Analytics

Ouvrez une nouvelle requête dans l'espace de travail BigQuery.
Exécutez l'instruction SQL suivante pour créer la table récapitulative associant les utilisateurs aux interactions avec les produits :

CREATE TABLE ecommerce_analytics.user_product_interactions (
    user_id STRING DEFAULT 'any user',
    product_id STRING,
    interaction_score INT
);

Attribuer des rôles au compte de service Compute

Attribuez au compte de service Compute par défaut les rôles dont la boîte à outils MCP et l'application ont besoin :

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

Vous pouvez également accéder à IAM et administration > IAM dans la console, cliquer sur Accorder l'accès, saisir le compte de service et ajouter les mêmes rôles.

7. Comprendre l'application de bout en bout

Pour comprendre comment chaque composant fonctionne avec les autres, nous allons créer une application d'e-commerce qui utilise plusieurs bases de données et services. L'application est créée avec un backend Python (Flask) et intègre plusieurs services et bases de données Google Cloud.

Comprendre la structure du répertoire

Dans la section suivante, vous allez cloner le dépôt polyglot-persist-ecommerce et l'utiliser pour exécuter l'application localement. Une fois l'application testée en local, nous déploierons MCP Toolbox et l'application sur Cloud Run.

Explorez les fichiers téléchargés dans ce répertoire. Les répertoires de premier niveau suivants sont présents :

UploadImages : stocke les composants Image, principalement utilisés pour la documentation ou le contenu visuel du catalogue de produits d'e-commerce.
static : stocke les éléments Web statiques de l'application, tels que les fichiers CSS et JavaScript, utilisés pour styliser l'interface utilisateur et y ajouter de l'interactivité ( source).
templates : stocke les modèles HTML (probablement Jinja2 pour Flask) utilisés par l'application Python pour afficher dynamiquement les pages Web du catalogue d'e-commerce ( source).

Les fichiers de ce dépôt fonctionnent ensemble pour créer, configurer et déployer une application d'e-commerce multidb. Les fichiers centraux comme app.py orchestrent le backend en intégrant diverses sources de données définies dans des fichiers SQL et JSON, tandis que les fichiers de configuration assurent un déploiement fluide dans les environnements cloud :

app.py : orchestre le backend Flask et les intégrations de plusieurs bases de données.
agentengine.py : logique de base pour initialiser et configurer les agents Vertex AI.
.env : stocke les secrets pour les connexions à la base de données et au stockage.
tools.yaml : configure MCP Toolbox pour les opérations de base de données multidb.
Dockerfile : définit l'image de conteneur et la configuration de l'environnement.
requirements.txt : liste les bibliothèques Python nécessaires à l'exécution de l'application.
tools.yaml : configurations pour MCP Toolbox.
Procfile : spécifie les commandes d'exécution de production pour le déploiement.
alloydb_insert_queries.sql : contient des requêtes SQL pour les données relationnelles.
product_details_export.json et user_interactions_export.json : fournissent des exemples de données JSON pour la base de données NoSQL.
README.md : guide la configuration, le déploiement et la compréhension du projet.

Flux de bout en bout de l'application

Configuration d'AlloyDB : provisionnez un cluster hautes performances et utilisez les scripts SQL fournis pour créer la table products_core_table avec des colonnes vectorielles pour les embeddings d'images.
Configuration de MongoDB Atlas : déployez un cluster sur Google Cloud pour stocker les attributs de produits fluides dans product_details et consigner les parcours de navigation en temps réel dans user_interactions.
Analyse BigQuery : créez un ensemble de données pour agréger les journaux d'interactions, ce qui permet d'exécuter des requêtes analytiques complexes qui identifient les cinq éléments les plus populaires parmi des millions d'événements.
Dépôt Cloud Storage : créez un bucket public pour héberger des images de produits en haute résolution, en veillant à ce que chaque élément soit accessible à l'aide d'une URL signée ou publique pour l'interface.
Déploiement de MCP Toolbox : déployez la boîte à outils sur Cloud Run, en l'établissant comme le pont RESTful central qui traduit l'intention en langage naturel en requêtes multi-bases de données.
Configuration de Tools.yaml : définissez vos "outils" (par exemple, get_product_core_data ou get_top_5_views) en mappant des opérations SQL et NoSQL spécifiques à des noms simples et lisibles par l'agent.
Logique de backend Flask : implémentez des routes app.py qui s'interfacent avec MCP Toolbox, en gérant la coordination de la récupération des données et en servant d'API pour l'UI.
Orchestration multi-agent : configurez les agents ADK dans le code pour qu'ils raisonnent en fonction de l'intention de l'utilisateur, en sélectionnant l'outil approprié pour résoudre les requêtes complexes de vente au détail provenant de plusieurs sources.
Intégration de l'interface : créez une interface index.html comprenant le catalogue de produits avec une fonctionnalité d'enregistrement des interactions, un onglet "Analytics" pour comprendre les analyses des performances des produits et un onglet "Agent" dédié qui utilise le chat multi-agent ADK pour offrir une expérience d'achat conversationnelle fluide.

Passons maintenant à l'implémentation de l'orchestration et des déploiements.

8. Configurer MCP Toolbox et le déployer sur Cloud Run

MCP Toolbox fait abstraction de nos multiples sources de données, ce qui permet à notre application de récupérer et d'écrire des données de manière uniforme.

Installer MCP Toolbox localement

Téléchargez le binaire MCP Toolbox dans votre répertoire d'accueil et rendez-le exécutable :

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

Configurer tools.yaml

Vous devez définir les abstractions pour AlloyDB, MongoDB et BigQuery. Le fichier tools.yaml indique à la boîte à outils MCP comment interagir avec chaque outil.

Le dépôt inclut déjà tools.yaml. Ouvrez-le :

cd ~/polyglot-persist-ecommerce
cloudshell edit tools.yaml

Remplacez les espaces réservés ***** par vos valeurs :

Base de données	Champ	Exemple de valeur
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` (ajoutez cette ligne sous `alloydb-source` si elle n'y figure pas)
MongoDB	`uri`	la chaîne de connexion que vous avez enregistrée précédemment

Faites pointer les aperçus d'images vers votre bucket :

sed -i "s/ecommerce-app-images/$BUCKET/g" tools.yaml

Tester l'UI de votre outil

Dans votre terminal Cloud Shell, exécutez la boîte à outils localement pour diffuser l'UI :
```
~/toolbox --config tools.yaml --ui --enable-api
```
Dans Cloud Shell, cliquez sur Aperçu sur le Web > Modifier le port, saisissez 5000, puis ajoutez /ui à la fin de l'URL qui s'ouvre.

L'interface utilisateur de MCP Toolbox s'affiche :

UI de MCP Toolbox

Lorsque vous avez terminé, appuyez sur Ctrl+C pour arrêter la boîte à outils locale.

Déployer dans Cloud Run

Déployer MCP Toolbox sur Cloud Run pour le rendre disponible en tant que service géré sécurisé que notre application peut utiliser pour interroger les bases de données. Nous allons stocker la configuration dans Secret Manager pour protéger les informations de connexion sensibles.

Importez la configuration tools.yaml dans Google Secret Manager :
```
gcloud secrets create tools --data-file=tools.yaml
```
Si vous modifiez tools.yaml ultérieurement, importez une nouvelle version avec :
```
gcloud secrets versions add tools --data-file=tools.yaml
```

Déployez à l'aide de l'image de conteneur MCP Toolbox publique :

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 active l'API REST utilisée par l'application Web.

Enregistrez l'URL de la boîte à outils :

export TOOLBOX_URL=$(gcloud run services describe toolbox --region us-central1 --format='value(status.url)')
echo $TOOLBOX_URL

Vous pouvez ouvrir $TOOLBOX_URL/ui dans votre navigateur pour voir les outils.

9. Configurer l'application d'e-commerce et la déployer sur Cloud Run

Maintenant que nos bases de données sont en cours d'exécution et que l'abstraction MCP Toolbox est déployée, nous pouvons exécuter l'application Web Flask.

Pour diffuser le catalogue de produits, l'application Flask traite les données en procédant comme suit :

Récupérer les données de base : récupère la liste complète des produits depuis AlloyDB (list_products_core).
Récupérer les détails étendus : récupère tous les détails du produit à partir de MongoDB (list_all_product_details).
Combiner des listes : concatène les deux listes.
Enrichir avec des contenus multimédias : ajoute l'URL de l'image Cloud Storage à chaque élément.

Créer le moteur d'agent

Installez les dépendances :
```
cd ~/polyglot-persist-ecommerce
pip install -r requirements.txt
```
Remarque : Cette étape peut prendre plusieurs minutes pour résoudre et installer les packages.

Initialisez et enregistrez l'agent IA à l'aide de Vertex AI Reasoning Engine :

export REASONING_ENGINE_LOCATION=us-central1
export APP_NAME=$(python agentengine.py)
echo $APP_NAME

Le résultat doit ressembler à ce qui suit :

projects/991742412753/locations/us-central1/reasoningEngines/4933254136889081856

L'application lit ses paramètres à partir de variables d'environnement, que vous transmettez dans la commande de déploiement ci-dessous. Vous n'avez donc pas besoin de modifier .env.

Déployer l'interface sur Cloud Run

Déployez l'application Web sur Cloud Run pour finaliser l'architecture :

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"

Votre application est désormais en ligne. Ouvrez l'URL du service fournie par Cloud Run pour afficher le catalogue Multidb Ecommerce. L'URL doit ressembler à ceci : https://polyglot-*********-uc.a.run.app/.

10. Explorer l'application

Cliquez sur Catalogue de produits pour afficher tous les produits.
Cliquez sur l'icône d'un produit pour afficher ses détails. Vous remarquerez que les images proviennent de Cloud Storage, que les informations détaillées sur le produit sont extraites de MongoDB et que l'inventaire des produits est extrait d'AlloyDB.
Interagissez avec le catalogue de produits pour générer des vues et des écritures fictives envoyées à MongoDB.
Cliquez sur ETL & Analytics pour afficher les analyses du produit. Vous remarquerez que les données analytiques sur les produits sont extraites de BigQuery.

Cliquez sur l'onglet Agent IA pour interagir avec l'agent IA. Posez des questions en langage naturel, par exemple :

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.

Comme vous pouvez le voir, la recherche renvoie exactement ce que nous avons demandé : un sac à dos sans composants en cuir, en stock et sans réclamations concernant la durabilité des bretelles dans les avis.

Agent IA

11. Effectuer un nettoyage

Pour éviter que des frais ne soient facturés sur votre compte Google Cloud, supprimez les ressources créées lors de cet atelier de programmation.

Exécutez les commandes Cloud Shell suivantes :

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

Vous pouvez également supprimer l'instance Agent Engine :

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

Vous pouvez également accéder à Vertex AI > Agent Engine dans la console Google Cloud et supprimer l'instance.

Vous pouvez également supprimer l'intégralité du projet Google Cloud et toutes ses ressources en exécutant la commande suivante :

gcloud projects delete $PROJECT_ID

12. Félicitations

Félicitations ! Vous avez créé une architecture Multidb cross-cloud.

Vous avez montré comment MCP Toolbox sert de lien architectural pour une application moderne et spécialisée. En associant la bonne base de données à la bonne tâche, vous avez obtenu les résultats suivants :

Écritures de données flexibles : MongoDB pour les journaux d'événements.
Cohérence transactionnelle : AlloyDB pour l'intégrité de base.
Analyses hautes performances : BigQuery pour l'informatique décisionnelle.
Développement unifié : un seul backend Python qui élimine toute la complexité à l'aide de MCP Toolbox.

Documents de référence

Pour en savoir plus sur les produits Google Cloud associés, consultez ces ateliers de programmation :

AlloyDB AI : Premiers pas avec les embeddings vectoriels AlloyDB AI
AlloyDB AI : embeddings multimodaux dans AlloyDB
MCP Toolbox : Installer et configurer MCP Toolbox for Databases sur AlloyDB

Pour en savoir plus sur les produits utilisés dans cet atelier de programmation, consultez les ressources suivantes :