Déployer un agent compatible avec la gouvernance d'entreprise avec MCP et Cloud Run

1. Introduction

Cet atelier de programmation fait partie d'une série en deux parties qui explique comment créer un agent d'IA générative tenant compte de la gouvernance.

(Vous pouvez lire la première partie de cette série, qui explique comment établir la base de données en appliquant des aspects Dataplex aux tables BigQuery et en testant les règles localement à l'aide de l'interface de ligne de commande Gemini. 👉 Lire la partie 1

Toutefois, les tests dans une CLI locale ne sont qu'un début. Pour déployer cette solution dans toute votre entreprise, vous avez besoin d'une sécurité centralisée, de connexions standardisées aux outils d'IA et d'un framework d'application approprié pour orchestrer la logique de l'agent et fournir une interface de chat familière.

Dans cette deuxième partie, vous allez relever ces défis et passer à la production. Vous allez déployer vos règles de gouvernance dans un serveur MCP central hébergé sur Cloud Run. Vous utiliserez ensuite l'Agent Development Kit (ADK) de Google pour créer l'application d'agent proprement dite et la connecter à vos outils MCP, avec une interface utilisateur Web professionnelle.

be15d5f41f0d716c.png

Prérequis

  • Un projet Google Cloud avec facturation activée.
  • Connaissances de base de Cloud Run, des comptes de service IAM et de Python.
  • Les ensembles de données BigQuery et les aspects Dataplex créés dans la partie 1. (Ne vous inquiétez pas si vous les avez supprimés. Nous vous fournissons un script ci-dessous pour les recréer rapidement.)

Points abordés

  • Découvrez comment utiliser le protocole MCP (Model Context Protocol) pour standardiser la façon dont les agents d'IA interagissent avec les données Google Cloud.
  • Déployer un serveur MCP sécurisé sur Cloud Run
  • Découvrez comment créer un agent IA à l'aide de l'Agent Development Kit (ADK) et le connecter à votre backend MCP.
  • Découvrez comment exécuter l'UI de développement intégrée d'ADK pour interagir avec votre agent contrôlé.

Prérequis

  • Accès à Google Cloud Shell

Concepts clés

  • MCP (Model Context Protocol) : considérez MCP comme un "câble USB-C universel" pour les agents d'IA. Au lieu d'écrire du code d'intégration d'API personnalisé pour chaque modèle d'IA, MCP fournit une méthode standard permettant à l'IA de se connecter de manière sécurisée à vos outils de données d'entreprise (comme Dataplex et BigQuery).
  • Agent Development Kit (ADK) : framework Open Source flexible de Google conçu pour simplifier le développement de bout en bout des agents d'IA. Il applique les principes de l'ingénierie logicielle à la création d'agents, ce qui vous permet d'orchestrer des outils complexes, de gérer l'état et de lancer facilement une interface utilisateur de développement intégrée pour les tests et le déploiement.

2. Préparation

Démarrer Cloud Shell

Bien que Google Cloud puisse être utilisé à distance depuis votre ordinateur portable, nous allons nous servir de Google Cloud Shell pour cet atelier de programmation, un environnement de ligne de commande exécuté dans le cloud.

Dans la console Google Cloud, cliquez sur l'icône Cloud Shell dans la barre d'outils supérieure :

Activer Cloud Shell

Le provisionnement et la connexion à l'environnement prennent quelques instants seulement. Une fois l'opération terminée, le résultat devrait ressembler à ceci :

Capture d'écran du terminal Google Cloud Shell montrant que l'environnement est connecté

Cette machine virtuelle contient tous les outils de développement nécessaires. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud, ce qui améliore nettement les performances du réseau et l'authentification. Vous pouvez effectuer toutes les tâches de cet atelier de programmation dans un navigateur. Vous n'avez rien à installer.

Initialiser l'environnement

Ouvrez Cloud Shell et définissez les variables de votre projet pour vous assurer que toutes les commandes ciblent la bonne infrastructure.

export PROJECT_ID=$(gcloud config get-value project)
gcloud config set project $PROJECT_ID
export REGION="us-central1"

Point de contrôle : reprendre ou reconstruire ?

Comme il s'agit de la partie 2, votre agent a besoin des données régies de la partie 1 pour fonctionner. Veuillez choisir votre parcours :

Parcours A : Je viens de terminer la partie 1 et mes ressources sont toujours en cours d'exécution.

Parfait ! Accédez au répertoire de travail. Vous êtes prêt à continuer.

cd ~/devrel-demos/data-analytics/governance-context

Parcours B : J'ai ignoré la partie 1 OU j'ai supprimé mes ressources (nettoyage).

Aucun problème. Vous trouverez ci-dessous un bloc de commande "Fast-Track". Cela reconstruira automatiquement le data lake BigQuery et appliquera les métadonnées de gouvernance Dataplex exactement comme nous l'avons fait dans la partie 1.

# 1. Clone the repo and navigate to the working directory
git clone --depth 1 --filter=blob:none --sparse https://github.com/GoogleCloudPlatform/devrel-demos.git
cd devrel-demos
git sparse-checkout set data-analytics/governance-context
cd data-analytics/governance-context

# 2. Rebuild the messy data lake with Terraform
cd terraform
terraform init
terraform apply -var="project_id=${PROJECT_ID}" -var="region=${REGION}" -auto-approve

# 3. Generate and apply Dataplex Aspects (Governance rules)
cd ..
chmod +x ./generate_payloads.sh ./apply_governance.sh
./generate_payloads.sh
./apply_governance.sh

3. Mise à l'échelle avec MCP : créer le plan de contrôle des données

Jusqu'à présent, vous avez testé votre logique de gouvernance à l'aide de Gemini CLI. C'est excellent pour le prototypage rapide, mais il s'exécute en local à l'aide de vos identifiants utilisateur personnels.

Dans un véritable environnement d'entreprise, vous avez besoin d'un plan de contrôle des données centralisé. Pour ce faire, nous allons utiliser la boîte à outils d'IA générative pour les bases de données, un projet Open Source officiel de Google. Cette boîte à outils fournit un serveur MCP prédéfini conçu spécifiquement pour connecter les agents d'IA de manière sécurisée aux bases de données et aux services de métadonnées Google Cloud, comme Dataplex.

En déployant cette boîte à outils en tant que serveur MCP sur Cloud Run, nous obtenons les avantages suivants :

  1. Identité centralisée : l'agent s'exécute en tant que compte de service restreint, et non en tant que compte utilisateur personnel.
  2. Normalisation : n'importe quel client (ADK, Gemini, applications personnalisées) peut se "brancher" sur ce serveur à l'aide du protocole MCP standard.
  3. Champ d'application contrôlé (principe du moindre privilège) : nous ne donnons pas au LLM un accès illimité à BigQuery. Nous le forçons à parcourir d'abord le catalogue de métadonnées Dataplex.

Configurer la définition de l'outil (tools.yaml)

La boîte à outils GenAI nécessite un fichier de configuration déclaratif, tools.yaml. Ce fichier définit le sources (où se connecter) et le tools (ce que l'IA est autorisée à faire).

  1. Accédez au répertoire du serveur et insérez votre ID de projet dans le fichier de configuration :
cd ~/devrel-demos/data-analytics/governance-context/mcp_server
envsubst < tools.yaml > tools.tmp && mv tools.tmp tools.yaml
cat tools.yaml

Elle doit être identique à l'extrait suivant. Vérifiez que le champ du projet correspond désormais à votre ID de projet Google Cloud.

sources:
  dataplex:
    kind: dataplex
    project: YOUR-PROJECT-ID

tools:
  search_entries:
    kind: dataplex-search-entries
    source: dataplex
    description: Search for entries in Dataplex Catalog.

  lookup_entry:
    kind: dataplex-lookup-entry
    source: dataplex
    description: Retrieve a specific entry from Dataplex Catalog.

  search_aspect_types:
    kind: dataplex-search-aspect-types
    source: dataplex
    description: Find aspect types relevant to a query.

toolsets:
  dataplex-toolset:
    - search_entries
    - lookup_entry
    - search_aspect_types

En définissant ces trois outils, nous pouvons forcer l'IA à être "en lecture seule" et "axée sur la gouvernance".

Sécuriser la configuration (Secret Manager)

Dans l'architecture d'entreprise, vous ne devez jamais intégrer de fichiers de configuration directement dans les images de conteneurs. Nous stockerons tools.yaml de manière sécurisée dans Google Cloud Secret Manager.

gcloud services enable secretmanager.googleapis.com
gcloud secrets create dataplex-tools-config --data-file=tools.yaml

Implémenter le principe du moindre privilège (IAM)

Ensuite, nous créons un compte de service dédié pour le serveur MCP de la boîte à outils IA générative. Cette identité ne disposera que des autorisations exactes requises pour lire le catalogue Dataplex et accéder aux données BigQuery.

export MCP_SA=mcp-sa
gcloud iam service-accounts create ${MCP_SA} \
    --display-name="Service Account for Dataplex MCP"
export MCP_SERVICE_ACCOUNT="${MCP_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

# Allow the server to read its own config from Secret Manager
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/secretmanager.secretAccessor"

# Allow the server to read Dataplex Metadata and BigQuery Data
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogViewer"
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer"

Déployer le serveur MCP sur Cloud Run

Nous allons maintenant déployer la boîte à outils d'IA générative. Nous utilisons l'image de conteneur prédéfinie de Google (database-toolbox/toolbox) et montons notre configuration à partir de Secret Manager (--set-secrets) au moment de l'exécution.

export IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:latest

gcloud run deploy governance-mcp \
    --image=$IMAGE \
    --service-account $MCP_SERVICE_ACCOUNT \
    --region=$REGION \
    --no-allow-unauthenticated \
    --set-secrets="/app/tools.yaml=dataplex-tools-config:latest" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080"

Vous avez maintenant établi une API régie. Au lieu d'accorder à votre frontend d'IA générative un accès direct à la base de données, il se connectera à cette URL Cloud Run. L'agent ne peut voir que ce que cette boîte à outils lui permet de voir.

4. Créer le backend de l'agent avec ADK

Vous avez établi un plan de contrôle des données (MCP) sécurisé et régi qui s'exécute sur Cloud Run. Votre agent d'IA a maintenant besoin d'un framework pour orchestrer sa logique, comme le traitement des entrées utilisateur, la décision du moment où appeler le serveur MCP et la mise en forme de la sortie.

Au lieu d'écrire tout ce code passe-partout à partir de zéro, nous allons utiliser l'Agent Development Kit (ADK) de Google. L'ADK est un framework axé sur le code qui encapsule automatiquement la logique de votre agent dans un backend FastAPI. De plus, il est fourni avec une UI de développeur intégrée, ce qui vous permet de visualiser instantanément le processus de raisonnement et les appels d'outils de l'agent sans avoir à créer d'abord une interface utilisateur personnalisée.

Inspecter la logique de l'agent (agent.py)

Avant de configurer l'infrastructure, examinons le cœur de cette application.

Accédez au répertoire et affichez le contenu d'agent.py. Ce fichier est le "cerveau" de votre déploiement ADK.

cd ~/devrel-demos/data-analytics/governance-context/mcp_server
cat agent.py

Examinez la structure du code. Il remplit trois fonctions essentielles avec un minimum de code récurrent :

  1. Intégration de MCPToolset : au lieu d'écrire des clients HTTP personnalisés pour interagir avec vos outils Dataplex, l'ADK utilise MCPToolset(server_url=mcp_url). Cela récupère dynamiquement la définition tools.yaml à partir de votre serveur MCP déployé et la traduit en appels de fonction natifs pour le LLM.
  2. Instructions système : le paramètre instructions contient les règles de gouvernance strictes (la même logique que celle que nous avons utilisée dans la CLI GEMINI.md). Il ordonne explicitement au modèle d'exécuter la boucle de raisonnement de la phase 1 (recherche de métadonnées) à la phase 2 (requête de données).
  3. Orchestration d'agents : la classe Agent(...) lie le modèle Gemini, l'invite système et les outils MCP. Une fois déployé, l'ADK convertit automatiquement cet objet en point de terminaison FastAPI évolutif.

Séparation des tâches : configurer l'identité du frontend

Pour exécuter ce code de manière sécurisée, nous devons indiquer à l'agent où se trouve votre serveur MCP. Nous allons construire l'URL de manière dynamique et l'enregistrer dans un fichier .env que l'ADK lira au moment de l'exécution.

Nous allons également créer une identité distincte (dataplex-agent-sa) pour cette application destinée aux utilisateurs. Cette séparation des tâches garantit que l'agent d'interface dispose d'autorisations différentes de celles du serveur de gouvernance de backend.

Exécutez les commandes suivantes pour configurer l'environnement et l'identité :

export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")
export MCP_SERVER_URL=https://governance-mcp-${PROJECT_NUMBER}.${REGION}.run.app/mcp

export AGENT_SA=dataplex-agent-sa
export AGENT_SERVICE_ACCOUNT="${AGENT_SA}@${PROJECT_ID}.iam.gserviceaccount.com"

gcloud iam service-accounts create ${AGENT_SA} \
    --display-name="Service Account for Dataplex Agent "

Configurer les variables d'exécution

Le framework ADK s'appuie sur des variables d'environnement pour comprendre son contexte. Nous devons définir explicitement l'ID du projet et la région, et activer l'utilisation de Vertex AI. Nous les ajoutons au même fichier .env.

echo MCP_SERVER_URL=$MCP_SERVER_URL > .env
echo GOOGLE_GENAI_USE_VERTEXAI=1 >> .env
echo GOOGLE_CLOUD_PROJECT=$PROJECT_ID >> .env
echo GOOGLE_CLOUD_LOCATION=$REGION >> .env

Accorder des autorisations

Même si l'agent délègue les vérifications de gouvernance au serveur MCP, il a toujours besoin d'autorisations de base pour fonctionner. Nous accordons exactement deux rôles :

  1. Utilisateur Vertex AI : pour appeler le modèle Gemini afin de générer des réponses en langage naturel.
  2. Demandeur Cloud Run : pour appeler l'API de votre serveur MCP de manière sécurisée. Il n'obtient pas d'accès direct à BigQuery ni à Dataplex.
gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user"

gcloud run services add-iam-policy-binding governance-mcp \
  --region=$REGION \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/run.invoker"

Déployer sur Cloud Run

Enfin, nous déployons la pile complète sur Cloud Run.

Nous utilisons uvx pour exécuter l'outil ADK sans installer manuellement les dépendances. La commande ci-dessous crée un package à partir de la logique agent.py, génère une image de conteneur, injecte votre compte de service et lance un serveur FastAPI. En ajoutant l'indicateur --with_ui, il regroupe également l'ADK Web Playground pour le débogage.

Cette commande crée le conteneur et le déploie. Cette opération peut prendre entre une et trois minutes.

uvx --from google-adk \
adk deploy cloud_run \
  --project=$PROJECT_ID \
  --region=$REGION \
  --service_name=dataplex-agent \
  --with_ui \
  . \
  -- \
  --service-account=$AGENT_SERVICE_ACCOUNT \
  --allow-unauthenticated

Une fois cette commande exécutée, une URL de service (e.g., https://dataplex-agent-xyz.run.app) s'affiche. Cliquez sur ce lien pour ouvrir votre interface de chat d'IA générative entièrement régie.

12a5fa4c2aaf381f.png

Flux architectural de bout en bout

Vous avez terminé le système. Lorsqu'un utilisateur interagit avec l'UI de l'ADK, la séquence suivante se produit :

  1. L'utilisateur envoie un prompt dans l'UI de développement de l'agent ADK.
  2. L'agent ADK (agent.py) traite l'entrée et appelle le modèle Gemini.
  3. Gemini détermine qu'il a besoin de contexte et demande au serveur MCP d'exécuter les outils Dataplex.
  4. Le serveur MCP applique les règles de gouvernance Dataplex et renvoie les métadonnées.
  5. Gemini synthétise la réponse fiable en fonction des métadonnées et la renvoie à l'utilisateur.

5. Tester l'agent Enterprise

Maintenant que votre agent est en ligne, revenons sur les scénarios de gouvernance testés précédemment avec l'interface de ligne de commande. La logique reste la même, mais vous interagissez désormais avec l'ADK Web Playground déployé, qui visualise l'état interne et les exécutions d'outils.

  1. Orchestration : l'agent ADK (exécuté sur Cloud Run) reçoit votre texte.
  2. Routage des outils : Gemini reconnaît que votre question nécessite un contexte de données et transfère la requête au serveur MCP.
  3. Vérification de la gouvernance : le serveur MCP (exécuté sur une instance Cloud Run distincte) interroge Dataplex pour obtenir des types d'aspect spécifiques.
  4. Synthèse : les métadonnées pertinentes sont renvoyées à Gemini pour générer la réponse finale.

Vérifier la logique de gouvernance

Ouvrez l'URL du service que vous avez générée à l'étape précédente (e.g., https://dataplex-agent-xyz.run.app) dans votre navigateur. Collez le prompt suivant :

"My dashboard needs to show what's happening right now with our ad spend. I can't wait for the overnight load. What do you recommend?"

Observez le processus de raisonnement de l'agent dans l'UI du développeur :

  1. Reconnaissance de l'intention : l'agent analyse les expressions "tout de suite" et "je ne peux pas attendre la nuit".
  2. Recherche de métadonnées : il appelle l'outil MCP search_aspect_types. Il recherche les composants de données dont l'aspect update_frequency est défini sur "REALTIME" (TEMPS RÉEL) ou "STREAMING" (DIFFUSION), plutôt que sur "DAILY" (QUOTIDIEN) ou "MONTHLY" (MENSUEL).
  3. Sélection : elle indique que la table mkt_realtime_campaign_performance répond à ces critères, tandis que fin_monthly_closing_internal (bien que de haute qualité) est trop lente pour votre requête.
  4. Réponse : l'agent recommande le tableau en temps réel.

e0da615724199e.png

Pourquoi c'est important :

Sans ces métadonnées de gouvernance, un LLM recommanderait probablement la table fin_monthly_closing_internal simplement parce qu'elle comporte une colonne nommée "ad_spend", en ignorant le fait que les données datent de 24 heures. Le contexte de vos métadonnées a empêché une erreur métier.

Vous pouvez également tester la requête "Board Meeting" (Réunion du conseil d'administration) pour voir comment l'agent passe à différentes tables en fonction de l'aspect "Niveau du produit de données" :

"We are preparing the deck for an internal Board of Directors meeting next week. I need the numbers to be absolutely finalized, trustworthy, and kept strictly confidential. Which table is safe to use?"

6. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet atelier de programmation soient facturées sur votre compte Google Cloud, suivez ces étapes pour détruire toute l'infrastructure créée dans les parties 1 et 2.

Détruire le lac de données (Terraform)

Utilisez Terraform pour supprimer les tables et ensembles de données BigQuery, ainsi que les définitions d'aspect Dataplex.

cd ~/devrel-demos/data-analytics/governance-context/terraform
terraform destroy -var="project_id=${PROJECT_ID}" -var="region=${REGION}" -auto-approve

Supprimer des services Cloud Run

Supprimez les ressources de calcul pour arrêter toute facturation active des conteneurs en cours d'exécution.

gcloud run services delete governance-mcp --region=$REGION --quiet
gcloud run services delete dataplex-agent --region=$REGION --quiet

Nettoyer les artefacts de compilation et l'espace de stockage intermédiaire

Lorsque vous avez déployé l'agent ADK à l'aide de uvx, le système a automatiquement créé une image de conteneur et importé votre code source dans un bucket Cloud Storage temporaire. Ces artefacts persistent même après la suppression du service Cloud Run et entraînent des frais de stockage continus.

Supprimez le dépôt Artifact Registry et le bucket de préproduction Cloud Storage :

# Delete the repository used for the agent build
gcloud artifacts repositories delete cloud-run-source-deploy \
    --location=$REGION \
    --quiet

# Delete the staging bucket created by Cloud Run source deploy
gcloud storage rm --recursive gs://run-sources-${PROJECT_ID}-${REGION}

Supprimer les identités, les autorisations et les secrets

Supprimez d'abord les liaisons de stratégie IAM pour éviter que des entrées"tombstone" (enregistrements orphelins) ne restent sur la page IAM de votre projet. Supprimez ensuite les comptes de service et les secrets de configuration.

# Remove IAM roles granted to the MCP Service Account
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/secretmanager.secretAccessor" --quiet
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/dataplex.catalogViewer" --quiet
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$MCP_SERVICE_ACCOUNT" \
  --role="roles/bigquery.dataViewer" --quiet

# Remove IAM roles granted to the Agent Service Account
gcloud projects remove-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$AGENT_SERVICE_ACCOUNT" \
  --role="roles/aiplatform.user" --quiet

# Delete the Service Accounts
gcloud iam service-accounts delete $MCP_SERVICE_ACCOUNT --quiet
gcloud iam service-accounts delete $AGENT_SERVICE_ACCOUNT --quiet

# Delete the Secret Manager entry
gcloud secrets delete dataplex-tools-config --quiet

Supprimer la configuration locale

Enfin, nettoyez les fichiers de configuration locaux et les variables d'environnement dans Cloud Shell.

# Uninstall the Gemini CLI extension (installed in Part 1)
gemini extensions uninstall dataplex

# Remove local repository files and unset variables
cd ~
rm -rf ~/devrel-demos
unset MCP_SERVER_URL
unset MCP_SERVICE_ACCOUNT
unset AGENT_SERVICE_ACCOUNT

7. Félicitations !

Vous avez déployé un agent d'IA générative de bout en bout, tenant compte de la gouvernance.

Dans cet atelier de programmation en deux parties, vous avez dépassé le simple prompt engineering pour implémenter une architecture robuste et prête pour la production. En traitant la gouvernance des données comme une condition préalable à l'IA générative, vous avez établi une méthode systématique pour empêcher le modèle de récupérer des données non certifiées ou hallucinées.

Points clés à retenir

  • IA déterministe grâce aux métadonnées : au lieu de laisser le LLM deviner la table correcte en fonction des noms de colonnes, vous avez appliqué une boucle de raisonnement stricte à l'aide de la boîte à outils d'IA générative pour les bases de données. En n'exposant explicitement que trois outils Dataplex (search_aspect_types, search_entries, lookup_entry), vous avez forcé le modèle à vérifier les certifications de données avant de synthétiser les réponses.
  • Architecture découplée (MCP) : en déployant le serveur MCP (Model Context Protocol) sur Cloud Run, vous avez abstrait vos règles de gouvernance des données dans une API centralisée et standardisée. L'agent de frontend n'a pas besoin de contenir une logique de base de données. Il doit uniquement communiquer via la norme MCP. Cela signifie que vous pouvez brancher n'importe quel futur modèle ou client d'IA sur le même backend contrôlé.
  • Séparation des tâches : vous avez appliqué le principe du moindre privilège en isolant les identités IAM. L'agent ADK destiné aux utilisateurs fonctionne avec des autorisations limitées à l'appel de modèle et au routage d'API, tandis que le serveur MCP de backend gère de manière sécurisée les requêtes de catalogue Dataplex et la récupération des données BigQuery.
  • Orchestration d'agents "code-first" : vous avez utilisé le Google Agent Development Kit (ADK) pour encapsuler instantanément la logique de votre agent Python dans un backend FastAPI évolutif, en utilisant son interface utilisateur de développement intégrée pour visualiser et déboguer les exécutions d'outils internes de l'agent.

Et ensuite ?