🤖 Créer un agent d'IA multimodal avec Graph RAG, ADK et Memory Bank

1. Introduction

1. Le défi

Dans les scénarios de réponse aux catastrophes, la coordination des survivants ayant des compétences, des ressources et des besoins différents dans plusieurs lieux nécessite des capacités intelligentes de gestion et de recherche de données. Cet atelier vous apprend à créer un système d'IA de production qui combine :

1. 🗄️ Base de données graphiques (Spanner) : stockez les relations complexes entre les survivants, les compétences et les ressources.
2. 🔍 Recherche optimisée par l'IA : recherche hybride sémantique et par mot clé à l'aide d'embeddings
3. 📸 Traitement multimodal : extraire des données structurées à partir d'images, de texte et de vidéos
4. 🤖 Orchestration multi-agent : coordonnez des agents spécialisés pour les workflows complexes.
5. 🧠 Mémoire à long terme : personnalisation avec Vertex AI Memory Bank

2. Objectifs de l'atelier

Une base de données de graphes du réseau de survivants avec :

• 🗺️ Visualisation interactive en 3D des relations entre les survivants
• 🔍 Recherche intelligente (par mots clés, sémantique et hybride)
• 📸 Pipeline d'importation multimodal (extraire des entités à partir d'images/vidéos)
• 🤖 Système multi-agents pour l'orchestration de tâches complexes
• 🧠 Intégration de Memory Bank pour des interactions personnalisées

3. Technologie principale

Composant	Technologie	Objectif
Database (Base de données)	Cloud Spanner Graph	Stocker les nœuds (survivants, compétences) et les arêtes (relations)
AI Search	Gemini + Embeddings	Compréhension sémantique et recherche par similarité
Framework de l'agent	ADK (Agent Development Kit)	Orchestrer des workflows d'IA
Mémoire	Vertex AI Memory Bank	Stockage à long terme des préférences utilisateur
Frontend	React + Three.js	Visualisation interactive de graphiques 3D

2. Préparation de l'environnement (à ignorer si vous êtes dans l'atelier)

Si vous avez participé à l'atelier Google WayBackHome et que vous avez déjà terminé les niveaux 0 et 1, veuillez ignorer cette session.

Première partie : Activer le compte de facturation

• Revendiquez votre compte de facturation avec un crédit de 5 $, dont vous aurez besoin pour votre déploiement. Assurez-vous d'utiliser votre compte Gmail.

Aucune carte de crédit ni aucun paiement ne sont nécessaires : vous recevrez 5 € de crédits sans frais. Cette opération prend moins de deux minutes. Il vous suffit de saisir votre nom et d'accepter les crédits.

Deuxième partie : Environnement ouvert

1. 👉 Cliquez sur ce lien pour accéder directement à l'éditeur Cloud Shell.
2. 👉 Si vous êtes invité à autoriser l'accès à un moment donné aujourd'hui, cliquez sur Autoriser pour continuer.
3. 👉 Si le terminal ne s'affiche pas en bas de l'écran, ouvrez-le :
   • Cliquez sur Afficher.
   • Cliquez sur Terminal.
4. 👉💻 Dans le terminal, vérifiez que vous êtes déjà authentifié et que le projet est défini sur votre ID de projet à l'aide de la commande suivante :

   gcloud auth list
   

5. 👉💻 Clonez le projet bootstrap depuis GitHub :

   git clone https://github.com/google-americas/way-back-home.git
   

3. Configuration de l'environnement

1. Initialiser

Dans le terminal de l'éditeur Cloud Shell, si le terminal n'apparaît pas en bas de l'écran, ouvrez-le :

• Cliquez sur Afficher.
• Cliquez sur Terminal

Si vous êtes dans un atelier et que vous avez remarqué que vous êtes actuellement dans (.venv), assurez-vous d'exécuter deactivate avant de continuer.

👉💻 Dans le terminal, rendez le script d'initialisation exécutable et exécutez-le :

cd ~/way-back-home/level_2
./init.sh

⚠️ Remarque concernant l'ID du projet : le script vous invite à créer un projet Google Cloud. Vous pouvez accepter l'ID de projet généré aléatoirement par défaut ou spécifier le vôtre.

2. Configurer le projet

👉 💻 Définissez votre ID de projet :

gcloud config set project $(cat ~/project_id.txt) --quiet

👉💻 Activez les API requises (cela prend environ deux à trois minutes) :

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

3. Exécuter le script de configuration

👉💻 Exécutez le script d'installation :

cd ~/way-back-home/level_2
./setup.sh

Cela créera .env pour vous. Dans votre Cloud Shell, ouvrez le projet way_back_home. Sous le dossier level_2, vous pouvez voir que le fichier .env a été créé pour vous. Si vous ne le trouvez pas, cliquez sur View > Toggle Hidden File pour l'afficher.

4. Charger des exemples de données

👉💻 Accédez au backend et installez les dépendances :

cd ~/way-back-home/level_2/backend
uv sync

👉💻 Chargez les données initiales des survivants :

uv run python ~/way-back-home/level_2/backend/setup_data.py

Cela crée :

• Instance Spanner (survivor-network)
• Base de données (graph-db)
• Toutes les tables de nœuds et d'arêtes
• Graphiques de propriétés pour les requêtes Résultat attendu :

============================================================
SUCCESS! Database setup complete.
============================================================

Instance:  survivor-network
Database:  graph-db
Graph:     SurvivorGraph

Access your database at:
https://console.cloud.google.com/spanner/instances/survivor-network/databases/graph-db?project=waybackhome

Si vous cliquez sur le lien après Access your database at dans le résultat, vous pouvez ouvrir la console Google Cloud Spanner.

Vous verrez Spanner dans la console Google Cloud.

4. Visualiser des données graphiques dans Spanner Studio

Ce guide vous aide à visualiser les données du graphique Survivor Network et à interagir avec elles directement dans la console Google Cloud à l'aide de Spanner Studio. C'est un excellent moyen de vérifier vos données et de comprendre la structure du graphique avant de créer votre agent d'IA.

1. Accéder à Spanner Studio

1. À la dernière étape, veillez à cliquer sur le lien et à ouvrir Spanner Studio.

2. Comprendre la structure du graphique ("vue d'ensemble")

Considérez l'ensemble de données Survivor Network comme un puzzle logique ou un état de jeu :

Entité	Rôle dans le système	Analogie
Survivants	Les agents/joueurs	Joueurs
Biomes	Où se trouvent-ils ?	Zones de carte
Compétences	Ce qu'ils peuvent faire	Fonctionnalités
Besoins	Ce qui leur manque (crises)	Quêtes/Missions
Ressources	Éléments trouvés dans le monde	Loot

Objectif : l'agent d'IA doit associer des compétences (solutions) à des besoins (problèmes), en tenant compte des biomes (contraintes de localisation).

🔗 Arêtes (relations) :

• SurvivorInBiome : suivi de la position
• SurvivorHasSkill : Inventaire des capacités
• SurvivorHasNeed : liste des problèmes actifs.
• SurvivorFoundResource : inventaire des articles
• SurvivorCanHelp : relation inférée (l'IA la calcule).

3. Interroger le graphique

Exécutons quelques requêtes pour découvrir l'histoire que racontent les données.

Spanner Graph utilise le langage GQL (Graph Query Language). Pour exécuter une requête, utilisez GRAPH SurvivorNetwork suivi de votre modèle de correspondance.

👉 Requête 1 : Le roster mondial (qui est où ?) C'est votre base : comprendre la localisation est essentiel pour les opérations de sauvetage.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[:SurvivorInBiome]->(b:Biomes)
RETURN TO_JSON(result) AS json_result

Le résultat devrait être le suivant :

Pourquoi c'est important :

• Pour les dispatchers : vous ne pouvez pas envoyer une personne de la zone volcanique pour secourir une personne dans la zone cryogénique.
• Pour l'agent d'IA : lorsqu'un utilisateur pose la question Qui se trouve dans la forêt ?, il s'agit du modèle de requête utilisé par l'agent.
• Visualisation : vous verrez quatre survivants répartis dans quatre biomes. Il s'agit de votre "vue de la carte".

👉 Requête 2 : La matrice de compétences (capacités) Maintenant que vous savez où se trouve chaque personne, découvrez ce qu'elle peut faire.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasSkill]->(k:Skills)
RETURN TO_JSON(result) AS json_result

Le résultat devrait être le suivant :

Pourquoi c'est important :

• Pour les responsables de l'équipe d'intervention : identifiez vos médecins, ingénieurs et navigateurs en un coup d'œil.
• Pour l'agent IA : lorsqu'un utilisateur pose la question "Qui connaît les premiers secours ?", cette requête le trouve.
• Niveaux de compétence : notez que l'arête h possède une propriété proficiency (expert/compétent/basique). Le graphique stocke les métadonnées de la relation.

👉 Requête 3 : Qui est en crise ? (Le tableau des missions) : découvrez les survivants qui ont besoin d'aide et ce dont ils ont besoin.

GRAPH SurvivorNetwork
MATCH result = (s:Survivors)-[h:SurvivorHasNeed]->(n:Needs)
RETURN TO_JSON(result) AS json_result

Le résultat devrait être le suivant :

Pourquoi c'est important :

• Pour les responsables de l'assistance : hiérarchisez les missions de sauvetage en fonction de leur urgence.
• Pour l'agent IA : il s'agit de la "liste des tâches", c'est-à-dire des problèmes à résoudre.

🔎 Avancé : mise en relation – Qui peut aider qui ?

C'est là que le graphique devient puissant. Cette requête permet de trouver les survivants qui possèdent des compétences permettant de répondre aux besoins des autres survivants.

GRAPH SurvivorNetwork
MATCH result = (helper:Survivors)-[:SurvivorHasSkill]->(skill:Skills)-[:SkillTreatsNeed]->(need:Needs)<-[:SurvivorHasNeed]-(helpee:Survivors)
RETURN TO_JSON(result) AS json_result

Le résultat devrait être le suivant :

aside positive Que fait cette requête ?

Au lieu de simplement afficher "Les premiers secours traitent les brûlures" (ce qui est évident d'après le schéma), cette requête trouve :

• Dr. Elena Frost (qui a une formation médicale) → peut soigner → Capitaine Tanaka (qui a des brûlures)
• David Chen (qui a suivi une formation de secouriste) → peut soigner → Lt. Park (qui a une entorse à la cheville)

Pourquoi cette fonctionnalité est-elle efficace ?

Avantage du graphique : il s'agit d'une traversée de quatre sauts :

1. Commencer avec un assistant (survivant)
2. Trouver leurs compétences
3. Associez ces compétences aux besoins qu'elles traitent
4. Trouvez les survivants qui ont ces besoins.

Sans graphique, vous devez :

• Interroger la table SurvivorHasSkill → obtenir les compétences
• Requête : tableau SkillTreatsNeed → trouver les besoins correspondants
• Interroger la table SurvivorHasNeed → trouver qui a ces besoins
• Joindre tous les résultats dans le code de l'application

Avec Spanner Graph, il s'agit d'une seule requête que la base de données optimise pour vous.

Ce que votre agent d'IA fera :

Lorsqu'un utilisateur pose la question Qui peut soigner les brûlures ?, l'agent :

1. Exécuter une requête de graphe similaire
2. Réponse : "Dr. Frost a une formation médicale et peut aider le capitaine Tanaka"
3. L'utilisateur n'a pas besoin de connaître les tables ni les relations intermédiaires.

5. Embeddings optimisés par l'IA dans Spanner

1. Pourquoi utiliser des embeddings ? (Aucune action, lecture seule)

Dans le scénario de survie, le temps est essentiel. Lorsqu'un survivant signale une urgence, comme I need someone who can treat burns ou Looking for a medic, il ne peut pas perdre de temps à deviner les noms exacts des compétences dans la base de données.

Le problème de la recherche traditionnelle :

• Correspondance exacte : une recherche de mot clé pour "médecin" ne trouvera pas "Formation médicale" ni "Premiers secours".
• Incohérence de vocabulaire : les survivants peuvent dire "médecin", "guérisseur" ou "ambulancier", mais la base de données stocke les noms formels des compétences.
• Perte de contexte : la requête "traiter les brûlures" devrait trouver à la fois "Formation médicale" ET "Premiers secours", mais une simple recherche textuelle ne comprendra pas la relation sémantique.

La solution : la recherche sémantique avec des embeddings : les embeddings convertissent le texte en vecteurs de 768 dimensions qui capturent le sens, et pas seulement l'orthographe. Les concepts similaires sont regroupés dans l'espace vectoriel. Par conséquent, le terme "médecin" trouve naturellement "formation médicale", même sans aucun chevauchement de mots.

Scénario réel : Survivor : Captain Tanaka has burns—we need medical help NOW!

Recherche traditionnelle par mot clé pour "médecin" → 0 résultat ❌

Recherche sémantique avec des embeddings : trouve "Formation médicale" et "Premiers secours" ✅

C'est exactement ce dont les agents ont besoin : une recherche intelligente et humaine qui comprend l'intention, et pas seulement les mots clés.

Pourquoi choisir Spanner ? : Au lieu d'exporter des données vers Python, de générer des embeddings en externe et de les réimporter (processus lent et sujet aux erreurs), ML.PREDICT de Spanner vous permet de :

• Générez des embeddings directement en SQL à l'aide des modèles Vertex AI.
• Stockez les vecteurs avec les données graphiques (pas de base de données vectorielle distincte).
• Effectuer des requêtes de recherche sémantique en temps réel lors des traversées de graphe

Cela crée un puissant système Graph RAG : relations graphiques (qui possède quelle compétence) + recherche sémantique (trouver des compétences par signification) = requêtes d'agent intelligent.

2. Créer un modèle d'embedding

Qu'est-ce que ML.PREDICT ?

ML.PREDICT est la fonction intégrée de Spanner qui vous permet d'appeler des modèles de machine learning directement depuis SQL, sans Python, sans exportation/importation ni services distincts. Considérez-le comme un pont entre votre base de données et Vertex AI en temps réel.

Fonctionnement :

1. Vous créez un modèle virtuel dans Spanner (il s'agit simplement d'une référence, aucune pondération de modèle n'est stockée localement).
2. Lorsque vous utilisez ML.PREDICT(model, data) dans une requête, Spanner envoie vos données à Vertex AI via l'API.
3. Vertex AI le traite et renvoie les résultats sous forme de colonnes dans le résultat SQL.

Pourquoi est-ce important ?

• ✅ Zero-ETL : traitez les données là où elles se trouvent, sans les exporter vers des scripts Python.
• ✅ Temps réel : générez des réponses LLM ou des embeddings à la volée lors des requêtes.
• ✅ Évolutivité : Spanner gère l'orchestration, Vertex AI gère le calcul

Nous allons maintenant créer un modèle qui convertit le texte en embeddings à l'aide de text-embedding-004 de Google.

👉 Dans Spanner Studio, exécutez cette requête SQL (remplacez $YOUR_PROJECT_ID par l'ID de votre projet) :

Veillez à remplacer $YOUR_PROJECT_ID. Vous trouverez l'ID de votre projet dans votre fichier .env.

‼️ Dans l'éditeur Cloud Shell, ouvrez File > Open Folder > way-back-home/level_2 pour afficher l'intégralité du projet.

👉 Exécutez cette requête dans Spanner Studio en copiant et en collant la requête ci-dessous, puis en cliquant sur le bouton "Exécuter" :

CREATE MODEL TextEmbeddings
INPUT(content STRING(MAX))
OUTPUT(embeddings STRUCT<values ARRAY<FLOAT32>>)
REMOTE OPTIONS (
    endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/text-embedding-004'
);

Si vous oubliez de remplacer $YOUR_PROJECT_ID et que vous l'exécutez déjà, assurez-vous de faire DROP MODEL TextEmbeddings; avant de réessayer.

Fonctionnement :

• Crée un modèle virtuel dans Spanner (aucune pondération de modèle n'est stockée en local).
• Pointe vers text-embedding-004 de Google sur Vertex AI
• Définit le contrat : l'entrée est un texte, la sortie est un tableau flottant de 768 dimensions.

Pourquoi "OPTIONS À DISTANCE" ?

• Spanner n'exécute pas le modèle lui-même
• Il appelle Vertex AI via l'API lorsque vous utilisez ML.PREDICT.
• Zero-ETL : pas besoin d'exporter les données vers Python, de les traiter et de les réimporter

Cliquez sur le bouton Run. Une fois l'opération réussie, vous pouvez voir le résultat ci-dessous :

Cela crée un "modèle virtuel" qui fait référence à text-embedding-004 de Vertex AI. Aucune donnée ne quitte Spanner. Elles sont appelées via l'API.

3. Ajouter une colonne d'embedding

👉 Ajoutez une colonne pour stocker les embeddings :

ALTER TABLE Skills ADD COLUMN skill_embedding ARRAY<FLOAT32>;

Cliquez sur le bouton Run. Une fois l'opération réussie, vous pouvez voir le résultat ci-dessous :

4. Générer des embeddings

👉 Utilisez l'IA pour créer des embeddings vectoriels pour chaque compétence :

UPDATE Skills
SET skill_embedding = (
    SELECT embeddings.values
    FROM ML.PREDICT(
        MODEL TextEmbeddings,
        (SELECT name AS content)
    )
)
WHERE skill_embedding IS NULL;

Cliquez sur le bouton Run. Une fois l'opération réussie, vous pouvez voir le résultat ci-dessous :

Si vous voyez l'erreur d'autorisation, veuillez refaire l'étape 2 Créer un modèle d'embedding. Assurez-vous de faire DROP MODEL TextEmbeddings; avant de réessayer.

Ce qui se passe : chaque nom d'application (par exemple, "premiers secours") est convertie en un vecteur de 768 dimensions représentant sa signification sémantique.

5. Valider les embeddings

👉 Vérifiez que les embeddings ont été créés :

SELECT 
    skill_id,
    name,
    ARRAY_LENGTH(skill_embedding) AS embedding_dimensions
FROM Skills
LIMIT 5;

Résultat attendu :

6. Tester la recherche sémantique

Nous allons maintenant tester le cas d'utilisation exact de notre scénario : trouver des compétences médicales à l'aide du terme "médecin".

👉 Trouver des compétences semblables à "médecin" :

WITH query_embedding AS (
    SELECT embeddings.values AS val
    FROM ML.PREDICT(MODEL TextEmbeddings, (SELECT "medic" AS content))
)
SELECT
    s.name AS skill_name,
    s.category,
    COSINE_DISTANCE(s.skill_embedding, (SELECT val FROM query_embedding)) AS distance
FROM Skills AS s
WHERE s.skill_embedding IS NOT NULL
ORDER BY distance ASC
LIMIT 10;

• Convertit le terme de recherche "médecin " de l'utilisateur en embedding
• Stocke les données dans la table temporaire query_embedding

Résultats attendus (plus la distance est faible, plus les éléments sont semblables) :

7. Créer un modèle Gemini pour l'analyse

👉 Créez une référence de modèle d'IA générative (remplacez $YOUR_PROJECT_ID par l'ID réel de votre projet) :

Veillez à remplacer $YOUR_PROJECT_ID. Vous trouverez l'ID de votre projet dans votre fichier .env.

CREATE MODEL GeminiPro
INPUT(prompt STRING(MAX))
OUTPUT(content STRING(MAX))
REMOTE OPTIONS (
    endpoint = '//aiplatform.googleapis.com/projects/$YOUR_PROJECT_ID/locations/us-central1/publishers/google/models/gemini-2.5-pro',
    default_batch_size = 1
);

Si vous oubliez de remplacer $YOUR_PROJECT_ID et que vous l'exécutez déjà, veillez à effectuer DROP MODEL GeminiPro; avant de réessayer.

Différence par rapport au modèle d'embeddings :

• Embeddings : texte → vecteur (pour la recherche de similarités)
• Gemini : texte → texte généré (pour le raisonnement/l'analyse)

8. Utiliser Gemini pour l'analyse de la compatibilité

👉 Analysez les paires de survivants pour vérifier leur compatibilité avec la mission :

WITH PairData AS (
    SELECT
        s1.name AS Name_A,
        s2.name AS Name_B,
        CONCAT(
            "Assess compatibility of these two survivors for a resource-gathering mission. ",
            "Survivor 1: ", s1.name, ". ",
            "Survivor 2: ", s2.name, ". ",
            "Give a score from 1-10 and a 1-sentence reason."
        ) AS prompt
    FROM Survivors s1
    JOIN Survivors s2 ON s1.survivor_id < s2.survivor_id
    LIMIT 1
)
SELECT
    Name_A,
    Name_B,
    content AS ai_assessment
FROM ML.PREDICT(
    MODEL GeminiPro,
    (SELECT Name_A, Name_B, prompt FROM PairData)
);

Résultat attendu :

Name_A          | Name_B            | ai_assessment
----------------|-------------------|----------------
"David Chen"    | "Dr. Elena Frost" | "**Score: 9/10** Their compatibility is extremely high as David's practical, hands-on scavenging skills are perfectly complemented by Dr. Frost's specialized knowledge to identify critical medical supplies and avoid biological hazards."

Fonctionnement :

1. Créer des requêtes à partir de données :

CONCAT("Assess compatibility...", "Survivor 1: ", s1.name, ...)

Résultat : "Assess compatibility of these two survivors for a resource-gathering mission. Survivor 1: David Chen. Survivor 2: Dr. Elena Frost. Give a score from 1-10 and a 1-sentence reason."

2. Envoyer à Gemini :

ML.PREDICT(MODEL GeminiPro, (SELECT prompt FROM PairData))

Spanner envoie la requête à l'API Gemini.

3. Gemini génère une réponse :

"**Score: 9/10** Their compatibility is extremely high as David's practical, 
hands-on scavenging skills are perfectly complemented by Dr. Frost's specialized 
knowledge to identify critical medical supplies and avoid biological hazards."

4. Renvoyer en tant que colonne : le texte généré est renvoyé en tant que colonne content.

Pourquoi utiliser les appels LLM dans la base de données ?

• Pas besoin d'exporter les données vers Python
• Traiter les données à leur emplacement
• Peut être étendu à des millions de lignes (traitement par lot)

6. Créer votre agent Graph RAG avec la recherche hybride

1. Présentation de l'architecture du système

Cette section explique comment créer un système de recherche multiméthode qui permet à votre agent de gérer différents types de requêtes de manière flexible. Le système comporte trois couches : couche Agent, couche Outil et couche Service.

Pourquoi trois couches ?

• Séparation des préoccupations : l'agent se concentre sur l'intention, les outils sur l'interface et le service sur l'implémentation.
• Flexibilité : l'agent peut forcer des méthodes spécifiques ou laisser l'IA effectuer le routage automatique.
• Optimisation : possibilité d'ignorer l'analyse d'IA coûteuse lorsque la méthode est connue

Dans cette section, vous allez principalement implémenter la recherche sémantique (RAG), qui consiste à trouver des résultats en fonction de leur signification et pas seulement de leurs mots clés. Nous expliquerons plus tard comment la recherche hybride fusionne plusieurs méthodes.

2. Implémentation du service RAG

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/services/hybrid_search_service.py

Recherchez le commentaire # TODO: REPLACE_SQL.

Remplacez toute cette ligne par le code suivant :

        # This is your working query from the successful run!
        sql = """
            WITH query_embedding AS (
                SELECT embeddings.values AS val
                FROM ML.PREDICT(
                    MODEL TextEmbeddings,
                    (SELECT @query AS content)
                )
            )
            SELECT
                s.survivor_id,
                s.name AS survivor_name,
                s.biome,
                sk.skill_id,
                sk.name AS skill_name,
                sk.category,
                COSINE_DISTANCE(
                    sk.skill_embedding, 
                    (SELECT val FROM query_embedding)
                ) AS distance
            FROM Survivors s
            JOIN SurvivorHasSkill shs ON s.survivor_id = shs.survivor_id
            JOIN Skills sk ON shs.skill_id = sk.skill_id
            WHERE sk.skill_embedding IS NOT NULL
            ORDER BY distance ASC
            LIMIT @limit
        """

Fonctionnement de cette requête :

Il s'agit d'une requête Graph RAG qui combine deux techniques puissantes :

1. Relations de graphiques (via des jointures SQL sur les tables de graphiques de Spanner)
2. Recherche sémantique (via les embeddings et COSINE_DISTANCE)

Attendez, ce n'est que du SQL ?

Oui. Spanner Graph vous permet d'interroger les relations de graphe à l'aide du SQL standard avec des instructions JOIN. La structure du graphique (survivants → compétences via des arêtes SurvivorHasSkill) est stockée dans des tables relationnelles que vous pouvez joindre. Cela diffère des bases de données graphiques traditionnelles qui nécessitent des langages de requête spécialisés comme Cypher ou Gremlin.

Pourquoi s'agit-il d'un "Graph RAG" ?

• Graphique : nous parcourons les relations (survivant → compétence) stockées dans la structure du graphique.
• RAG : nous utilisons des embeddings pour récupérer du contenu sémantiquement similaire (génération augmentée par récupération).
• Résultat : trouvez des survivants en fonction de la signification des compétences qu'ils possèdent, en suivant les connexions du graphique.

Exemple : la requête "médecin" permet de trouver les survivants qui ont des compétences en "Formation médicale" ou en "Premiers secours", même si le terme "médecin" n'apparaît pas exactement dans la base de données.

3. Définition de l'outil de recherche sémantique

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/agent/tools/hybrid_search_tools.py

Dans hybrid_search_tools.py, localisez le commentaire # TODO: REPLACE_SEMANTIC_SEARCH_TOOL.

👉 Remplacez toute cette ligne par le code suivant :

async def semantic_search(query: str, limit: int = 10) -> str:
    """
    Force semantic (RAG) search using embeddings.
    
    Use this when you specifically want to find things by MEANING,
    not just matching keywords. Great for:
    - Finding conceptually similar items
    - Handling vague or abstract queries
    - When exact terms are unknown
    
    Example: "healing abilities" will find "first aid", "surgery", 
    "herbalism" even though no keywords match exactly.
    
    Args:
        query: What you're looking for (describe the concept)
        limit: Maximum results
        
    Returns:
        Semantically similar results ranked by relevance
    """
    try:
        service = _get_service()
        result = service.smart_search(
            query, 
            force_method=SearchMethod.RAG,
            limit=limit
        )
        
        return _format_results(
            result["results"],
            result["analysis"],
            show_analysis=True
        )
        
    except Exception as e:
        return f"Error in semantic search: {str(e)}"

Quand l'agent utilise :

• Requêtes demandant une similarité ("trouve des éléments semblables à X")
• Requêtes conceptuelles ("capacités de guérison")
• Lorsque la compréhension du sens est essentielle

4. Guide de décision de l'agent (instructions)

Dans la définition de l'agent, copiez-collez la partie liée à la recherche sémantique dans l'instruction.

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

L'agent utilise cette instruction pour sélectionner l'outil approprié :

👉 Dans le fichier agent.py, recherchez le commentaire # TODO: REPLACE_SEARCH_LOGIC, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

- `semantic_search`: Force RAG/embedding search
  Use for: "Find similar to X", conceptual queries, unknown terminology
  Example: "Find skills related to healing"

👉 Localisez le commentaire # TODO: ADD_SEARCH_TOOLReplace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

    semantic_search,         # Force RAG

5. Comprendre le fonctionnement de la recherche hybride (lecture seule, aucune action requise)

Dans les étapes 2 à 4, vous avez implémenté la recherche sémantique (RAG), la méthode de recherche principale qui trouve des résultats par signification. Mais vous avez peut-être remarqué que le système s'appelle "Recherche hybride". Voici comment tout cela s'imbrique :

Les trois méthodes de recherche disponibles :

1. Recherche sémantique (RAG) : ce que vous venez d'implémenter

• Utilise des embeddings + COSINE_DISTANCE
• Idéal pour : les requêtes conceptuelles, la recherche de "similaire à X"
• Exemple : "capacités de guérison" trouve "premiers secours", "chirurgie", "herboristerie"

2. Recherche par mot clé : filtrage SQL traditionnel

• Utilise des clauses LIKE et des catégories exactes
• Idéal pour : les filtres spécifiques tels que le biome ou la catégorie
• Exemple : "compétences médicales en forêt" filtre par catégorie ET par lieu

3. Recherche hybride : combine les deux méthodes

• Exécute les deux recherches et fusionne les résultats avec des scores pondérés
• Idéal pour : les requêtes complexes avec des concepts ET des filtres
• Exemple : "Qui peut m'aider à me soigner en montagne ?"

Fonctionnement de la fusion hybride :

Dans le fichier way-back-home/level_2/backend/services/hybrid_search_service.py, lorsque hybrid_search() est appelé, le service exécute LES DEUX recherches et fusionne les résultats :

# Location: backend/services/hybrid_search_service.py

    rank_kw = keyword_ranks.get(surv_id, float('inf'))
    rank_rag = rag_ranks.get(surv_id, float('inf'))

    rrf_score = 0.0
    if rank_kw != float('inf'):
        rrf_score += 1.0 / (K + rank_kw)
    if rank_rag != float('inf'):
        rrf_score += 1.0 / (K + rank_rag)

    combined_score = rrf_score

Lorsque hybrid_search() est appelé, le service exécute LES DEUX recherches et fusionne les résultats à l'aide de la fusion de classement réciproque (RRF).

Qu'est-ce que le RRF ? La RRF est un algorithme standard permettant de fusionner des listes classées provenant de différents moteurs de recherche sans avoir à normaliser leurs scores. Il fonctionne en attribuant un score en fonction de la position dans le classement (1er, 2e, 3e) plutôt que du score de similarité brut.

Quand utiliser chaque méthode ?

L'agent (backend/agent/agent.py) prend une décision en fonction de la requête :

Type de requête	L'agent choisit	Pourquoi
"Trouve des survivants dans la forêt"	keyword_search	Filtre simple, aucune sémantique nécessaire
"Qui peut soigner les blessures ?"	semantic_search	Conceptuel, besoin de sens
"Aide médicale en montagne"	hybrid_search	Comporte à la fois un concept et un filtre

Pour cet atelier de programmation, vous avez implémenté le composant de recherche sémantique (RAG), qui constitue la base. Les méthodes par mots clés et hybrides sont déjà implémentées dans le service. Votre agent peut utiliser les trois.

Félicitations ! Vous avez terminé de créer votre agent Graph RAG avec la recherche hybride.

7. Tester votre agent avec ADK Web

Le moyen le plus simple de tester votre agent est d'utiliser la commande adk web, qui lance votre agent avec une interface de chat intégrée.

1. Exécuter l'agent

👉💻 Accédez au répertoire backend (où votre agent est défini) et lancez l'interface Web :

cd ~/way-back-home/level_2/backend
uv run adk web

Cette commande démarre l'agent défini dans .

agent/agent.py

et ouvre une interface Web pour les tests.

👉 Ouvrez l'URL :

La commande génère une URL locale (généralement http://127.0.0.1:8000 ou similaire). Ouvrez-le dans votre navigateur.

Une fois que vous avez cliqué sur l'URL, l'interface utilisateur Web de l'ADK s'affiche. Assurez-vous de sélectionner l'agent en haut à gauche.

2. Tester les fonctionnalités de recherche

L'agent est conçu pour acheminer intelligemment vos requêtes. Essayez les entrées suivantes dans la fenêtre de chat pour voir différentes méthodes de recherche en action.

🧬 A. Graph RAG (recherche sémantique)

Trouve des éléments en fonction de leur signification et de leur concept, même si les mots clés ne correspondent pas.

Requêtes de test : (choisissez l'une des options ci-dessous)

Who can help with injuries?

What abilities are related to survival?

Éléments à prendre en compte :

• Le raisonnement doit mentionner la recherche sémantique ou RAG.
• Vous devriez obtenir des résultats conceptuellement liés (par exemple, "Chirurgie" lorsque vous demandez "Premiers secours").
• Les résultats seront accompagnés de l'icône 🧬.

🔀 B. Recherche hybride

Combine les filtres de mots clés avec la compréhension sémantique pour les requêtes complexes.

Requêtes de test : (choisissez l'une des options ci-dessous)

Find someone who can ply a plane in the volcanic area

Who has healing abilities in the FOSSILIZED?

Who has healing abilities in the mountains?

Éléments à prendre en compte :

• La justification doit mentionner la recherche hybride.
• Les résultats doivent correspondre aux DEUX critères (concept + lieu/catégorie).
• Les résultats trouvés par les deux méthodes sont accompagnés de l'icône 🔀 et sont classés en premier.

👉💻 Une fois les tests terminés, mettez fin au processus en appuyant sur Ctrl+C dans votre ligne de commande.

8. Exécuter l'application complète

Présentation de l'architecture Full Stack

Ajouter SessionService et Runner

👉💻 Dans le terminal, ouvrez le fichier chat.py dans l'éditeur Cloud Shell en exécutant la commande suivante (assurez-vous d'avoir appuyé sur Ctrl+C pour mettre fin au processus précédent avant de continuer) :

cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py

👉 Dans le fichier chat.py, recherchez le commentaire # TODO: REPLACE_INMEMORY_SERVICES, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

    session_service = InMemorySessionService()
    memory_service = InMemoryMemoryService()

👉 Dans le fichier chat.py, recherchez le commentaire # TODO: REPLACE_RUNNER, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

runner = Runner(
    agent=root_agent, 
    session_service=session_service,
    memory_service=memory_service,
    app_name="survivor-network"
)

1. Commencer l'inscription

Si le terminal précédent est toujours en cours d'exécution, mettez-y fin en appuyant sur Ctrl+C.

👉💻 Démarrer l'application :

cd ~/way-back-home/level_2/
./start_app.sh

Lorsque le backend démarre correctement, Local: http://localhost:5173/" s'affiche, comme suit :

👉 Cliquez sur Local : http://localhost:5173/ dans le terminal.

2. Tester la recherche sémantique

Requête :

Find skills similar to healing

Ce qui se passe :

• L'agent reconnaît la demande de similarité
• Génère un embedding pour "guérison"
• Utilise la distance de cosinus pour trouver des compétences sémantiquement similaires
• Résultats : premiers secours (même si les noms ne correspondent pas à "soins")

3. Tester la recherche hybride

Requête :

Find medical skills in the mountains

Ce qui se passe :

1. Composant de mot clé : filtrez sur category='medical'
2. Composant sémantique : intégrer "médical" et classer par similarité
3. Fusionner : combine les résultats en privilégiant ceux trouvés par les deux méthodes 🔀

Requête(facultatif) :

Who is good at survival and in the forest?

Ce qui se passe :

• Mots clés trouvés : biome='forest'
• Résultats sémantiques : compétences similaires à "survie"
• La méthode hybride combine les deux pour obtenir les meilleurs résultats.

👉💻 Lorsque vous avez terminé les tests, appuyez sur Ctrl+C dans le terminal pour y mettre fin.

9. Pipeline multimodal : couche d'outillage

Pourquoi avons-nous besoin d'un pipeline multimodal ?

Le réseau de survie n'est pas qu'un texte. Les survivants sur le terrain envoient des données non structurées directement par chat :

• 📸 Images : photos de ressources, de dangers ou d'équipements
• 🎥 Vidéos : rapports d'état ou diffusions SOS
• 📄 Texte : notes ou journaux de terrain

Le défi : pour rendre ces données consultables ("Où se trouve l'eau ?"), nous devons extraire des entités structurées (Personne, Ressource, Lieu) de ces fichiers et les enregistrer dans le graphique.

Scénario concret :

Un utilisateur importe une photo d'une trousse de premiers secours dans le chat.

Le système doit :

1. Importer le fichier dans GCS
2. Utiliser Gemini pour "voir" la trousse de premiers secours
3. Enregistrer un nœud "Resource" dans Spanner
4. Confirmez à l'utilisateur : "J'ai enregistré la trousse de premiers secours dans la base de données."

Quels fichiers traitons-nous ?

Contrairement à l'étape précédente, où nous avons recherché des données existantes, nous allons ici traiter les fichiers importés par l'utilisateur. L'interface chat.py gère les pièces jointes de manière dynamique :

Source	Contenu	Objectif
Association d'utilisateurs	Image/Vidéo/Texte	Informations à ajouter au graphique
Contexte du chat	"Voici une photo des fournitures"	Intention et informations supplémentaires

Approche prévue : pipeline d'agents séquentiels

Nous utilisons un agent séquentiel (multimedia_agent.py) qui enchaîne des agents spécialisés :

Ce paramètre est défini dans backend/agent/multimedia_agent.py en tant que SequentialAgent.

La couche d'outillage fournit les capacités que les agents peuvent invoquer. Les outils gèrent le "comment" : importer des fichiers, extraire des entités et enregistrer dans la base de données.

1. Ouvrir le fichier d'outils

👉💻 Ouvrez un nouveau terminal. Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell :

cloudshell edit ~/way-back-home/level_2/backend/agent/tools/extraction_tools.py

2. Implémenter l'outil upload_media

Cet outil importe un fichier local dans Google Cloud Storage.

👉 Dans extraction_tools.py, recherchez le commentaire pass # TODO: REPLACE_UPLOAD_MEDIA_FUNCTION.

Remplacez toute cette ligne par le code suivant :

    """
    Upload media file to GCS and detect its type.
    
    Args:
        file_path: Path to the local file
        survivor_id: Optional survivor ID to associate with upload
        
    Returns:
        Dict with gcs_uri, media_type, and status
    """
    try:
        if not file_path:
            return {"status": "error", "error": "No file path provided"}
        
        # Strip quotes if present
        file_path = file_path.strip().strip("'").strip('"')
        
        if not os.path.exists(file_path):
            return {"status": "error", "error": f"File not found: {file_path}"}
        
        gcs_uri, media_type, signed_url = gcs_service.upload_file(file_path, survivor_id)
        
        return {
            "status": "success",
            "gcs_uri": gcs_uri,
            "signed_url": signed_url,
            "media_type": media_type.value,
            "file_name": os.path.basename(file_path),
            "survivor_id": survivor_id
        }
    except Exception as e:
        logger.error(f"Upload failed: {e}")
        return {"status": "error", "error": str(e)}

3. Implémenter l'outil extract_from_media

Cet outil est un routeur : il vérifie le media_type et l'envoie à l'extracteur approprié (texte, image ou vidéo).

👉 Dans extraction_tools.py, localisez le commentaire pass # TODO: REPLACE_EXTRACT_FROM_MEDIA.

Remplacez toute cette ligne par le code suivant :

    """
    Extract entities and relationships from uploaded media.
    
    Args:
        gcs_uri: GCS URI of the uploaded file
        media_type: Type of media (text/image/video)
        signed_url: Optional signed URL for public/temporary access
        
    Returns:
        Dict with extraction results
    """
    try:
        if not gcs_uri:
             return {"status": "error", "error": "No GCS URI provided"}

        # Select appropriate extractor
        if media_type == MediaType.TEXT.value or media_type == "text":
            result = await text_extractor.extract(gcs_uri)
        elif media_type == MediaType.IMAGE.value or media_type == "image":
            result = await image_extractor.extract(gcs_uri)
        elif media_type == MediaType.VIDEO.value or media_type == "video":
            result = await video_extractor.extract(gcs_uri)
        else:
            return {"status": "error", "error": f"Unsupported media type: {media_type}"}
            
        # Inject signed URL into broadcast info if present
        if signed_url:
            if not result.broadcast_info:
                result.broadcast_info = {}
            result.broadcast_info['thumbnail_url'] = signed_url
        
        return {
            "status": "success",
            "extraction_result": result.to_dict(), # Return valid JSON dict instead of object
            "summary": result.summary,
            "entities_count": len(result.entities),
            "relationships_count": len(result.relationships),
            "entities": [e.to_dict() for e in result.entities],
            "relationships": [r.to_dict() for r in result.relationships]
        }
    except Exception as e:
        logger.error(f"Extraction failed: {e}")
        return {"status": "error", "error": str(e)}

Informations clés sur l'implémentation :

• Entrée multimodale : nous transmettons à generate_content à la fois la requête textuelle (_get_extraction_prompt()) et l'objet image.
• Sortie structurée : response_mime_type="application/json" garantit que le LLM renvoie un JSON valide, ce qui est essentiel pour le pipeline.
• Association d'entités visuelles : la requête inclut des entités connues afin que Gemini puisse reconnaître des personnages spécifiques.

4. Implémenter l'outil save_to_spanner

Cet outil conserve les entités et les relations extraites dans la base de données Spanner Graph.

👉 Dans extraction_tools.py, localisez le commentaire pass # TODO: REPLACE_SPANNER_AGENT.

Remplacez toute cette ligne par le code suivant :

    """
    Save extracted entities and relationships to Spanner Graph DB.
    
    Args:
        extraction_result: ExtractionResult object (or dict from previous step if passed as dict)
        survivor_id: Optional survivor ID to associate with the broadcast
        
    Returns:
        Dict with save statistics
    """
    try:
        # Handle if extraction_result is passed as the wrapper dict from extract_from_media
        result_obj = extraction_result
        if isinstance(extraction_result, dict) and 'extraction_result' in extraction_result:
             result_obj = extraction_result['extraction_result']
        
        # If result_obj is a dict (from to_dict()), reconstruct it
        if isinstance(result_obj, dict):
            from extractors.base_extractor import ExtractionResult
            result_obj = ExtractionResult.from_dict(result_obj)
        
        if not result_obj:
            return {"status": "error", "error": "No extraction result provided"}
            
        stats = spanner_service.save_extraction_result(result_obj, survivor_id)
        
        return {
            "status": "success",
            "entities_created": stats['entities_created'],
            "entities_existing": stats['entities_found_existing'],
            "relationships_created": stats['relationships_created'],
            "broadcast_id": stats['broadcast_id'],
            "errors": stats['errors'] if stats['errors'] else None
        }
    except Exception as e:
        logger.error(f"Spanner save failed: {e}")
        return {"status": "error", "error": str(e)}

En fournissant aux agents des outils de haut niveau, nous assurons l'intégrité des données tout en tirant parti de leurs capacités de raisonnement.

5. Mettre à jour le service GCS

GCSService gère l'importation du fichier vers Google Cloud Storage.

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell :

cloudshell edit ~/way-back-home/level_2/backend/services/gcs_service.py

👉 Dans le fichier gcs_service.py, recherchez le commentaire # TODO: REPLACE_SAVE_TO_GCS à l'intérieur de la fonction upload_file.

Remplacez toute cette ligne par le code suivant :

        blob = self.bucket.blob(blob_name)
        blob.upload_from_filename(file_path)

En abstrayant cela dans un service, l'agent n'a pas besoin de connaître les buckets GCS, les noms de blobs ni la génération d'URL signées. Il vous demande simplement d'importer le fichier.

6. (Lecture seule) Pourquoi le workflow agentique > les approches traditionnelles ?

Il existe deux façons traditionnelles de créer ce pipeline. Les deux présentent des inconvénients majeurs que le workflow agentique résout.

❌ Approche 1 : Pipeline de données par lot (simple, mais fragile)

Voici un exemple de script de lot qui traite les fichiers de manière séquentielle :

# Traditional batch pipeline
for file in ["broadcast_1.txt", "broadcast_2.png", "broadcast_3.mp4"]:
   gcs_uri = upload_to_gcs(file)        # Fails if file corrupted → CRASH
   entities = extract_entities(gcs_uri) # No error handling
   save_to_db(entities)                 # Saves even if extraction empty → WASTE
   # How do you tell the user progress? Print to console?

Problèmes :

• ❌ Aucune adaptabilité : si un fichier échoue, l'ensemble du script plante.
• ❌ Pas de contexte : ne peut pas ajuster son comportement en fonction de l'intention de l'utilisateur ("C'est urgent !")
• ❌ Échecs silencieux : erreurs masquées dans les journaux, l'utilisateur n'a aucune idée de ce qui s'est passé
• ❌ Aucun commentaire de l'utilisateur : le script s'exécute en arrière-plan, l'utilisateur attend sans rien voir

❌ Approche 2 : Architecture événementielle (cloud native, mais complexe)

Configuration cloud traditionnelle :

1. Importations utilisateur vers GCS
2. Un événement GCS déclenche une fonction Cloud
3. Appels de fonction à l'API Vision
4. Fonction qui écrit dans la base de données
5. …Comment indiquer à l'utilisateur que l'opération est terminée ? (WebSockets/Polling requis)

Problèmes :

• ❌ Complexité élevée : gérer au moins cinq services (GCS, Eventarc, Cloud Functions, Pub/Sub, etc.)
• ❌ État découplé : il est difficile de transmettre des données entre les gestionnaires d'événements.
• ❌ Cauchemar de débogage : journaux dispersés sur plusieurs services
• ❌ Déconnecté de l'utilisateur : les événements s'exécutent en arrière-plan, sans contexte de conversation

✅ Notre approche : pipeline séquentiel agentique

multimedia_agent.py utilise un SequentialAgent qui orchestre le pipeline de manière intelligente :

# Agentic pipeline (simplified conceptual view)
Agent: "I'll upload your file..."
Tool: upload_media → Success ✅
Agent: "Great! Now extracting entities..."
Tool: extract_from_media → Found 3 survivors, 2 resources ✅
Agent: "Perfect! Saving to database..."
Tool: save_to_spanner → Saved as broadcast #456 ✅
Agent: "Done! I found 3 survivors and 2 resources in your image. Saved to the graph."

L'avantage de l'agentivité :

Fonctionnalité	Pipeline par lot	En fonction des événements	Workflow agentif
Complexité	Faible (1 script)	Élevée (5 services ou plus)	Faible (1 fichier Python : multimedia_agent.py)
Gestion de l'état	Variables globales	Élevée (découplée)	Unifié (état de l'agent)
Gestion des erreurs	Plantages	Journaux silencieux	Interactive ("Je n'ai pas pu lire ce fichier")
Commentaires des utilisateurs	Impressions sur console	Recherche nécessaire	Immédiat (partie du chat)
Adaptabilité	Logique fixe	Fonctions rigides	Intelligente (le LLM décide de l'étape suivante)
Conscience du contexte	Aucun	Aucun	Complète (connaît l'intention de l'utilisateur)

Exemple concret :

Script de lot :

Processing file 1... Done.
Processing file 2... ERROR: Corrupted image
[CRASH - User has to restart entire batch]

Workflow agentif :

User: "Here are 3 images of our supply cache"
Agent: "Processing image 1... Found medical supplies ✅"
Agent: "Processing image 2... This file seems corrupted. Skipping. ⚠️"
Agent: "Processing image 3... Found food supplies ✅"
Agent: "Summary: I successfully processed 2 of 3 images. Would you like to re-upload image 2?"

Pourquoi est-ce important ? En utilisant multimedia_agent.py (un SequentialAgent avec quatre sous-agents : Upload → Extract → Save → Summary), nous remplaçons une infrastructure complexe ET des scripts fragiles par une logique d'application intelligente et conversationnelle.

10. Pipeline multimodal : couche de l'agent

La couche d'agent définit l'intelligence, c'est-à-dire les agents qui utilisent des outils pour accomplir des tâches. Chaque agent a un rôle spécifique et transmet le contexte à l'agent suivant. Vous trouverez ci-dessous un schéma d'architecture pour un système multi-agents.

1. Ouvrir le fichier de l'agent

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell :

cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py

2. Définir l'agent d'importation

Cet agent extrait un chemin d'accès à un fichier du message de l'utilisateur et l'importe dans GCS.

👉 Dans le fichier multimedia_agent.py, recherchez le commentaire # TODO: REPLACE_UPLOAD_AGENT.

Remplacez toute cette ligne par le code suivant :

upload_agent = LlmAgent(
    name="UploadAgent",
    model="gemini-2.5-flash",
    instruction="""Extract the file path from the user's message and upload it.

Use `upload_media(file_path, survivor_id)` to upload the file.
The survivor_id is optional - include it if the user mentions a specific survivor (e.g., "survivor Sarah" -> "Sarah").
If the user provides a path like "/path/to/file", use that.

Return the upload result with gcs_uri and media_type.""",
    tools=[upload_media],
    output_key="upload_result"
)

3. Définir l'agent d'extraction

Cet agent "voit" le contenu multimédia importé et extrait des données structurées à l'aide de Gemini Vision.

👉 Dans le fichier multimedia_agent.py, recherchez le commentaire # TODO: REPLACE_EXTRACT_AGENT.

Remplacez toute cette ligne par le code suivant :

extraction_agent = LlmAgent(
    name="ExtractionAgent", 
    model="gemini-2.5-flash",
    instruction="""Extract information from the uploaded media.

Previous step result: {upload_result}

Use `extract_from_media(gcs_uri, media_type, signed_url)` with the values from the upload result.
The gcs_uri is in upload_result['gcs_uri'], media_type in upload_result['media_type'], and signed_url in upload_result['signed_url'].

Return the extraction results including entities and relationships found.""",
    tools=[extract_from_media],
    output_key="extraction_result"
)

Notez que instruction fait référence à {upload_result}. C'est ainsi que l'état est transmis entre les agents dans ADK.

4. Définir l'agent Spanner

Cet agent enregistre les entités et les relations extraites dans la base de données de graphes.

👉 Dans le fichier multimedia_agent.py, recherchez le commentaire # TODO: REPLACE_SPANNER_AGENT.

Remplacez toute cette ligne par le code suivant :

spanner_agent = LlmAgent(
    name="SpannerAgent",
    model="gemini-2.5-flash", 
    instruction="""Save the extracted information to the database.

Upload result: {upload_result}
Extraction result: {extraction_result}

Use `save_to_spanner(extraction_result, survivor_id)` to save to Spanner.
Pass the WHOLE `extraction_result` object/dict from the previous step.
Include survivor_id if it was provided in the upload step.

Return the save statistics.""",
    tools=[save_to_spanner],
    output_key="spanner_result"
)

Cet agent reçoit le contexte des deux étapes précédentes (upload_result et extraction_result).

5. Définir l'agent Summary

Cet agent synthétise les résultats de toutes les étapes précédentes dans une réponse conviviale.

👉 Dans le fichier multimedia_agent.py, recherchez le commentaire summary_instruction="" # TODO: REPLACE_SUMMARY_AGENT_PROMPT.

Remplacez toute cette ligne par le code suivant :

USE_MEMORY_BANK = os.getenv("USE_MEMORY_BANK", "false").lower() == "true"
save_msg = "6. Mention that the data is also being synced to the memory bank." if USE_MEMORY_BANK else ""

summary_instruction = f"""Provide a user-friendly summary of the media processing.

Upload: {{upload_result}}
Extraction: {{extraction_result}}
Database: {{spanner_result}}

Summarize:
1. What file was processed (name and type)
2. Key information extracted (survivors, skills, needs, resources found) - list names and counts
3. Relationships identified
4. What was saved to the database (broadcast ID, number of entities)
5. Any issues encountered
{save_msg}

Be concise but informative."""

Cet agent n'a pas besoin d'outils. Il se contente de lire le contexte partagé et de générer un résumé clair pour l'utilisateur.

🧠 Résumé de l'architecture

intégrée	Fichier	Responsabilité
Outils	extraction_tools.py + gcs_service.py	Comment faire ? : importer, extraire, enregistrer
Agent	multimedia_agent.py	Quoi : orchestrer le pipeline

11. Pipeline de données multimodales : orchestration

Le cœur de notre nouveau système est le MultimediaExtractionPipeline défini dans backend/agent/multimedia_agent.py. Il utilise le modèle Sequential Agent de l'ADK (Agent Development Kit).

1. Pourquoi utiliser les campagnes séquentielles ?

Le traitement d'un import est une chaîne de dépendances linéaires :

1. Vous ne pouvez pas extraire de données tant que vous n'avez pas le fichier (importation).
2. Vous ne pouvez pas enregistrer de données tant que vous ne les avez pas extraites.
3. Vous ne pouvez pas résumer tant que vous n'avez pas les résultats (Enregistrer).

Un SequentialAgent est idéal pour cela. Il transmet la sortie d'un agent en tant que contexte/entrée à l'agent suivant.

2. Définition de l'agent

Examinons comment le pipeline est assemblé en bas de multimedia_agent.py : 👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/agent/multimedia_agent.py

Il reçoit des entrées des deux étapes précédentes. Recherchez le commentaire # TODO: REPLACE_ORCHESTRATION. Remplacez toute cette ligne par le code suivant :

    sub_agents=[upload_agent, extraction_agent, spanner_agent, summary_agent]

3. Contacter l'agent racine

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

Recherchez le commentaire # TODO: REPLACE_ADD_SUBAGENT. Remplacez toute cette ligne par le code suivant :

    sub_agents=[multimedia_agent],

Cet objet unique regroupe quatre "experts" en une seule entité appelable.

4. Flux de données entre les agents

Chaque agent stocke sa sortie dans un contexte partagé auquel les agents suivants peuvent accéder :

5. Ouvrez l'application (ignorez cette étape si l'application est toujours en cours d'exécution).

Si le processus de votre application précédente est toujours ouvert, vous pouvez ignorer cette étape.

👉💻 Démarrer l'application :

cd ~/way-back-home/level_2/
./start_app.sh

👉 Cliquez sur Local : http://localhost:5173/ dans le terminal.

6. Tester l'importation d'images

👉 Dans l'interface de chat, choisissez l'une des photos ci-dessous et importez-la dans l'interface utilisateur :

• test_photo1,
• test_photo2,
• test_photo3,
• test_photo4

Dans l'interface de chat, expliquez à l'agent votre contexte spécifique :

Here is the survivor note

Joignez ensuite l'image ici.

👉💻 Dans le terminal, une fois les tests terminés, appuyez sur "Ctrl+C" pour mettre fin au processus.

Que se passe-t-il en arrière-plan ?

1. UploadAgent :

• Importe le fichier dans Google Cloud Storage
• Détecte le type de contenu (image/texte/vidéo)
• Génère une URL signée pour l'accès

2. ExtractionAgent :

• Télécharge une image depuis GCS
• Envoi à Gemini Vision avec une requête d'extraction
• L'IA analyse l'image pour :
  • Survivants (noms, conditions, rôles)
  • Ressources (fournitures médicales, outils)
  • Lieux (biomes, coordonnées)
  • Relations (qui possède quoi, qui est où)

3. SpannerAgent :

• Crée des nœuds d'entité dans Spanner.
• Crée des arêtes de relation
• Crée un enregistrement de diffusion avec une miniature

4. SummaryAgent :

• Synthétise un résumé convivial
• Renvoie un rapport structuré

6. Vérifier l'importation multimodale dans un bucket GCS

• Ouvrez Google Cloud Console Storage.
• Sélectionnez "bucket" dans Cloud Storage.

• Sélectionnez votre bucket, puis cliquez sur media.

• Affichez l'image que vous avez importée ici.

7. Vérifier l'importation multimodale dans Spanner (facultatif)

Vous trouverez ci-dessous un exemple de résultat dans l'UI pour test_photo1.

Vous avez importé test_photo1 avec la note Here is the survivor note. Vous pouvez voir le message.

**Summary:** A field report written on a clipboard details the discovery of an 'Energy Crystal' by David Chen in a 'Bioluminescent Forest', with the status marked as 'Critical'. The scene also includes a lit lantern, a pen, and a compass.

**Entities Found:**
*   **David Chen** (Survivor): The agent who filed this field report. His known role is Engineer.
*   **Engineer** (Skill): David Chen's known role or skill.
*   **Energy Crystal** (Resource): A newly discovered resource, depicted as a glowing blue crystal in a sketch on the report. Its purpose is implied to be energy-related.
*   **Bioluminescent Forest** (Biome): The location where the energy crystal was found. This matches the known biome description of a dark forest with glowing purple/neon plants and mushrooms.
*   **Critical Situation** (Need): The overall status of the situation is critical, indicating an urgent need for attention, response, or resource allocation.

**Relationships Found:**
*   **David Chen** (Survivor) found **Energy Crystal** (Resource).
*   **David Chen** (Survivor) is in **Bioluminescent Forest** (Biome).
*   **David Chen** (Survivor) has the skill **Engineer**.I have successfully saved the extracted information to the Spanner database.

Here are the save statistics:
*   **Broadcast ID:** `5892fb58-a120-46ca-80c2-0e04da7d6ea7`
*   **Entities Created:** 4
*   **Existing Entities:** 1
*   **Relationships Created:** 3
*   **Status:** successHere's a summary of the media processing:

Dans ce cas, nous devons vérifier si Spanner a bien mis à jour les informations suivantes :

*   **David Chen** (Survivor) found **Energy Crystal** (Resource).
*   **David Chen** (Survivor) is in **Bioluminescent Forest** (Biome).
*   **David Chen** (Survivor) has the skill **Engineer**.I have 

• Ouvrez Google Cloud Console Spanner.
• Sélectionnez votre instance : Survivor Network
• Sélectionnez votre base de données : graph-db
• Dans la barre latérale de gauche, cliquez sur Spanner Studio.

👉 Dans Spanner Studio, interrogez les nouvelles données :

SELECT 
  s.name AS Survivor,
  s.role AS Role,
  b.name AS Biome,
  r.name AS FoundResource,
  s.created_at
FROM Survivors s
LEFT JOIN SurvivorInBiome sib ON s.survivor_id = sib.survivor_id
LEFT JOIN Biomes b ON sib.biome_id = b.biome_id
LEFT JOIN SurvivorFoundResource sfr ON s.survivor_id = sfr.survivor_id
LEFT JOIN Resources r ON sfr.resource_id = r.resource_id
ORDER BY s.created_at DESC;

Nous pouvons le vérifier en consultant le résultat ci-dessous :

12. Banque de mémoire avec Agent Engine

1. Fonctionnement de la mémoire

Le système utilise une approche à double mémoire pour gérer à la fois le contexte immédiat et l'apprentissage à long terme.

2. Que sont les thèmes de souvenirs ?

Les thèmes de mémoire définissent les catégories d'informations que l'agent doit mémoriser au cours des conversations. Considérez-les comme des classeurs pour différents types de préférences utilisateur.

Pourquoi ne pas utiliser une seule grande mémoire ?

• ❌ Mémoire générique : "L'utilisateur a dit quelque chose à propos de la recherche… et a besoin de… et de biomes…"
• ✅ Thèmes organisés : séparation claire entre le comportement de recherche et la surveillance urgente

Nos deux thèmes :

1. search_preferences : la façon dont l'utilisateur aime effectuer des recherches
   • Préfèrent-ils la recherche par mots clés ou la recherche sémantique ?
   • Quelles compétences/quels biomes recherchent-ils souvent ?
   • Exemple de mémoire : "L'utilisateur préfère la recherche sémantique pour les compétences médicales"
2. urgent_needs_context : les crises qu'ils suivent
   • Quelles ressources surveillent-ils ?
   • Quels survivants sont concernés ?
   • Exemple de mémoire : "L'utilisateur suit la pénurie de médicaments dans le camp nord"

Pourquoi deux thèmes ?

• Précision : le LLM peut extraire des faits dans la bonne catégorie.
• Récupération : lorsque l'utilisateur demande "Trouve des survivants ayant des compétences médicales", l'agent récupère les informations à partir de search_preferences, et non à partir de données urgentes sans rapport.
• Évolutivité : vous pouvez ajouter d'autres thèmes ultérieurement (par exemple, favorite_survivors, alliance_tracking)

Fonctionnement : lorsque vous discutez avec l'agent, la banque de mémoire extrait automatiquement les faits qui correspondent à ces descriptions de thèmes et les enregistre. La prochaine fois que vous démarrerez une nouvelle session, l'agent récupérera les souvenirs pertinents pour personnaliser les réponses.

3. Configurer des thèmes de mémoire

Les thèmes de mémoire personnalisés définissent ce que l'agent doit retenir. Ils sont configurés lors du déploiement d'Agent Engine.

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/deploy_agent.py

~/way-back-home/level_2/backend/deploy_agent.py s'ouvre dans votre éditeur.

Nous définissons des objets de structure MemoryTopic pour indiquer au LLM les informations à extraire et à enregistrer.

👉 Dans le fichier deploy_agent.py, remplacez # TODO: SET_UP_TOPIC par ce qui suit :

# backend/deploy_agent.py

    custom_topics = [
        # Topic 1: Survivor Search Preferences
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="search_preferences",
                description="""Extract the user's preferences for how they search for survivors. Include:
                - Preferred search methods (keyword, semantic, direct lookup)
                - Common filters used (biome, role, status)
                - Specific skills they value or frequently look for
                - Geographic areas of interest (e.g., "forest biome", "mountain outpost")
                
                Example: "User prefers semantic search for finding similar skills."
                Example: "User frequently checks for survivors in the Swamp Biome."
                """,
            )
        ),
        # Topic 2: Urgent Needs Context
        MemoryTopic(
            custom_memory_topic=CustomMemoryTopic(
                label="urgent_needs_context",
                description="""Track the user's focus on urgent needs and resource shortages. Include:
                - Specific resources they are monitoring (food, medicine, ammo)
                - Critical situations they are tracking
                - Survivors they are particularly concerned about
                
                Example: "User is monitoring the medicine shortage in the Northern Camp."
                Example: "User is looking for a doctor for the injured survivors."
                """,
            )
        )
    ]

4. Intégration de l'agent

Le code de l'agent doit connaître la Memory Bank pour enregistrer et récupérer des informations.

👉💻 Dans le terminal, ouvrez le fichier dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/agent/agent.py

~/way-back-home/level_2/backend/agent/agent.py s'ouvre dans votre éditeur.

Création d'agents

Lorsque nous créons l'agent, nous transmettons after_agent_callback pour nous assurer que les sessions sont enregistrées en mémoire après les interactions. La fonction add_session_to_memory s'exécute de manière asynchrone pour éviter de ralentir la réponse du chat.

👉 Dans le fichier agent.py, recherchez le commentaire # TODO: REPLACE_ADD_SESSION_MEMORY, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

async def add_session_to_memory(
        callback_context: CallbackContext
) -> Optional[types.Content]:
    """Automatically save completed sessions to memory bank in the background"""
    if hasattr(callback_context, "_invocation_context"):
        invocation_context = callback_context._invocation_context
        if invocation_context.memory_service:
            # Use create_task to run this in the background without blocking the response
            asyncio.create_task(
                invocation_context.memory_service.add_session_to_memory(
                    invocation_context.session
                )
            )
            logger.info("Scheduled session save to memory bank in background")

Enregistrement en arrière-plan

👉 Dans le fichier agent.py, recherchez le commentaire # TODO: REPLACE_ADD_MEMORY_BANK_TOOL, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

if USE_MEMORY_BANK:
    agent_tools.append(PreloadMemoryTool())

👉 Dans le fichier agent.py, recherchez le commentaire # TODO: REPLACE_ADD_CALLBACK, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

    after_agent_callback=add_session_to_memory if USE_MEMORY_BANK else None

Configurer le service de session Vertex AI

👉💻 Dans le terminal, ouvrez le fichier chat.py dans l'éditeur Cloud Shell en exécutant la commande suivante :

cloudshell edit ~/way-back-home/level_2/backend/api/routes/chat.py

👉 Dans le fichier chat.py, recherchez le commentaire # TODO: REPLACE_VERTEXAI_SERVICES, Replace this whole line (Remplacez toute cette ligne) et remplacez-le par le code suivant :

    session_service = VertexAiSessionService(
        project=project_id,
        location=location,
        agent_engine_id=agent_engine_id
    )
    memory_service = VertexAiMemoryBankService(
        project=project_id,
        location=location,
        agent_engine_id=agent_engine_id
    )

4. Configuration et déploiement

Avant de tester les fonctionnalités de mémoire, vous devez déployer l'agent avec les nouveaux thèmes de mémoire et vous assurer que votre environnement est correctement configuré.

Nous avons fourni un script pratique pour gérer ce processus.

Exécuter le script de déploiement

👉💻 Dans le terminal, exécutez le script de déploiement :

cd ~/way-back-home/level_2
./deploy_and_update_env.sh

Ce script effectue les actions suivantes :

• Exécute backend/deploy_agent.py pour enregistrer les thèmes de l'agent et de la mémoire auprès de Vertex AI.
• Capture le nouvel ID du moteur d'agent.
• Mise à jour automatique de votre fichier .env avec AGENT_ENGINE_ID.
• Assurez-vous que USE_MEMORY_BANK=TRUE est défini dans votre fichier .env.

[!IMPORTANT] Si vous apportez des modifications à custom_topics dans deploy_agent.py, vous devez réexécuter ce script pour mettre à jour Agent Engine.

13. Valider la banque de données avec des données multimodales

Vous pouvez vérifier que la banque de mémoire fonctionne en enseignant une préférence à l'agent et en vérifiant si elle persiste au fil des sessions.

1. Ouvrez l'application (ignorez cette étape si elle est déjà en cours d'exécution).

Ouvrez à nouveau l'application en suivant les instructions ci-dessous : si le terminal précédent est toujours en cours d'exécution, mettez-y fin en appuyant sur Ctrls+C.

👉💻 Démarrer l'application :

cd ~/way-back-home/level_2/
./start_app.sh

👉 Cliquez sur Local : http://localhost:5173/ dans le terminal.

2. Tester la banque de mémoire avec du texte

Dans l'interface de chat, expliquez à l'agent votre contexte spécifique :

"I'm planning a medical rescue mission in the mountains. I need survivors with first aid and climbing skills."

👉 Patientez environ 30 secondes pour que la mémoire soit traitée en arrière-plan.

2. Démarrer une nouvelle session

Actualisez la page pour effacer l'historique des conversations en cours (mémoire à court terme).

Posez une question qui s'appuie sur le contexte que vous avez fourni précédemment :

"What kind of missions am I interested in?"

Réponse attendue :

"D'après vos conversations précédentes, vous vous intéressez à :

• Missions de sauvetage médical
• Opérations en montagne/en haute altitude
• Compétences requises : premiers secours, escalade

Voulez-vous que je trouve des survivants correspondant à ces critères ?"

3. Tester avec l'importation d'images

Importez une image et posez la question suivante :

remember this

Vous pouvez choisir l'une des photos ici ou la vôtre, puis l'importer dans l'UI :

• test_photo1,
• test_photo2,
• test_photo3,
• test_photo4

4. Vérifier dans Vertex AI Agent Engine

Accédez à Agent Engine dans la console Google Cloud.

1. Assurez-vous de sélectionner le projet dans le sélecteur de projets en haut à gauche :
2. Vérifiez le moteur d'agent que vous venez de déployer à partir de la commande précédente use_memory_bank.sh :Cliquez sur le moteur d'agent que vous venez de créer.
3. Cliquez sur l'onglet Memories de cet agent déployé pour afficher toute la mémoire.

👉💻 Lorsque vous avez terminé de tester, cliquez sur "Ctrl+C" dans votre terminal pour mettre fin au processus.

🎉 Félicitations ! Vous venez d'associer la Memory Bank à votre agent.

14. Déployer dans Cloud Run

1. Exécuter le script de déploiement

👉💻 Exécutez le script de déploiement :

cd ~/way-back-home/level_2
./deploy_cloud_run.sh

Une fois le déploiement réussi, vous obtiendrez l'URL de déploiement : .

👉💻 Avant de récupérer l'URL, accordez l'autorisation en exécutant la commande suivante :

source .env && gcloud run services add-iam-policy-binding survivor-frontend --region $REGION --member=allUsers --role=roles/run.invoker && gcloud run services add-iam-policy-binding survivor-backend --region $REGION --member=allUsers --role=roles/run.invoker

Accédez à l'URL déployée pour voir votre application en direct.

2. Comprendre le pipeline de compilation

Le fichier cloudbuild.yaml définit les étapes séquentielles suivantes :

1. Compilation du backend : compile l'image Docker à partir de backend/Dockerfile.
2. Déploiement du backend : déploie le conteneur de backend sur Cloud Run.
3. Capture URL : obtient la nouvelle URL du backend.
4. Compilation du frontend :
   • Installe les dépendances.
   • Crée l'application React en injectant VITE_API_URL=.
5. Image de l'interface : crée l'image Docker à partir de frontend/Dockerfile (en empaquetant les éléments statiques).
6. Frontend Deploy : déploie le conteneur de l'interface.

3. Vérifier le déploiement

Une fois la compilation terminée (consultez le lien vers les journaux fourni par le script), vous pouvez vérifier les points suivants :

1. Accédez à la console Cloud Run.
2. Recherchez le service survivor-frontend.
3. Cliquez sur l'URL pour ouvrir l'application.
4. Exécutez une requête de recherche pour vous assurer que le frontend peut communiquer avec le backend.

4. (!UNIQUEMENT POUR LES PARTICIPANTS À L'ATELIER) Mettre à jour votre position

👉 💻 Exécutez le script de finalisation :

cd ~/way-back-home/level_2
./set_level_2.sh

Si vous n'avez pas participé à l'atelier et terminé le niveau 0, un message d'erreur s'affiche.

Ouvrez waybackhome.dev. Vous verrez que votre position a été mise à jour. Bravo, vous avez terminé le niveau 2 !

(FACULTATIF) 5. Déploiement manuel

Si vous préférez exécuter les commandes manuellement ou mieux comprendre le processus, voici comment utiliser cloudbuild.yaml directement.

Écriture cloudbuild.yaml

Un fichier cloudbuild.yaml indique à Google Cloud Build les étapes à exécuter.

• steps : il s'agit d'une liste d'actions séquentielles. Chaque étape s'exécute dans un conteneur (par exemple, docker, gcloud, node, bash).
• substitutions : variables pouvant être transmises au moment de la compilation (par exemple, $_REGION).
• workspace : répertoire partagé dans lequel les étapes peuvent partager des fichiers (comme nous partageons backend_url.txt).

Exécuter le déploiement

Pour effectuer le déploiement manuellement sans le script, utilisez la commande gcloud builds submit. Vous DEVEZ transmettre les variables de substitution requises.

# Load your env vars first or replace these values manually
export PROJECT_ID=your-project-id
export REGION=us-central1

gcloud builds submit --config cloudbuild.yaml \
    --project "$PROJECT_ID" \
    --substitutions _REGION="us-central1",_GOOGLE_API_KEY="",_AGENT_ENGINE_ID="your-agent-id",_USE_MEMORY_BANK="TRUE",_GOOGLE_GENAI_USE_VERTEXAI="TRUE"

15. Conclusion

1. Ce que vous avez créé

✅ Base de données graphiques : Spanner avec des nœuds (survivants, compétences) et des arêtes (relations)
✅ Recherche IA : recherche par mots clés, sémantique et hybride avec des embeddings
✅ Pipeline multimodal : extraction d'entités à partir d'images/vidéos avec Gemini
✅ Système multi-agents : workflow coordonné avec ADK
✅ Banque de mémoire : personnalisation à long terme avec Vertex AI
✅ Déploiement en production : Cloud Run + Agent Engine

2. Résumé de l'architecture

3. Points clés

1. Graph RAG : combine la structure de la base de données graphiques avec des embeddings sémantiques pour une recherche intelligente
2. Modèles multi-agents : pipelines séquentiels pour les workflows complexes en plusieurs étapes
3. IA multimodale : extraire des données structurées à partir de contenus multimédias non structurés (images/vidéos)
4. Agents avec état : la banque de mémoire permet la personnalisation entre les sessions

4. Contenu de l'atelier

• Level0 : Identifiez-vous
• Level1 : Emplacement précis
• Niveau 2 : celui-ci : Créer un agent d'IA multimodal avec Graph RAG, ADK et Memory Bank
• Level3 : Créer un agent de streaming bidirectionnel ADK
• Level4 : Système multi-agents bidirectionnel en direct
• Level5 : Architecture événementielle avec Google ADK, A2A et Kafka

5. Ressources

• Documentation ADK
• Spanner Graph
• Guide Memory Bank
• Dépôt GitHub

Félicitations ! Vous avez créé un système d'agents d'IA de qualité professionnelle avec une base de données de graphiques, une recherche RAG, un traitement multimodal et une mémoire à long terme. Ces modèles s'appliquent à tous les domaines nécessitant une coordination intelligente des données, de la logistique aux services client en passant par la santé.