Construis ton 1er agent multi-agent avec Google ADK en 90 min

Bonjour, ici Eric. Si tu regardes les annonces IA depuis six mois, tu as vu passer « multi-agent » dans chaque communiqué. Aujourd’hui je t’emmène faire le truc : on installe Google ADK Python, on assemble trois agents qui parlent entre eux, on les teste en local, puis on déploie sur Cloud Run. 90 minutes, pas plus. Tu auras un vrai système qui tourne et un template réutilisable.

Prérequis : Python 3.11+, un compte Google Cloud (gratuit pour ce tutoriel), une clé API Gemini ou OpenAI. Pas besoin d’être expert Python — si tu sais écrire une fonction et lancer un pip install, ça ira.

Pourquoi ADK et pas un autre framework

Le marché des frameworks multi-agent est saturé : LangGraph, CrewAI, AutoGen, MetaGPT, Block Goose, smolagents. Pourquoi Google ADK ?

Trois raisons. D’abord, il est code-first : tu écris du Python normal, pas un DSL graphique. Ensuite, il est agnostique du modèle : Gemini, OpenAI, Anthropic, Mistral via LiteLLM, tout passe. Enfin, il s’intègre avec Vertex AI et Cloud Run sans friction — tu pousses ton agent en prod avec une seule commande gcloud. Pour un développeur indépendant ou une petite équipe, c’est le rapport signal/bruit le plus favorable de 2026.

Étape 1 — Installation (5 minutes)

Ouvre ton terminal. Crée un dossier de travail et un environnement virtuel propre :

mkdir mon-agent && cd mon-agent
python3 -m venv .venv
source .venv/bin/activate
pip install google-adk google-generativeai python-dotenv

Tu récupères ta clé API Gemini sur aistudio.google.com, tu la colles dans un fichier .env :

GOOGLE_API_KEY=ton-api-key-ici
GOOGLE_GENAI_USE_VERTEXAI=false

Vérifie l’installation :

python -c "from google.adk.agents import LlmAgent; print('OK')"

Si tu vois « OK », tu es prêt. Sinon, vérifie ta version de Python — ADK exige 3.11 minimum.

Étape 2 — Ton premier agent solo (10 minutes)

Avant le multi-agent, on fait un agent simple. Crée agent_base.py :

from google.adk.agents import LlmAgent
from dotenv import load_dotenv
load_dotenv()

recherche_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    description="Agent qui cherche des infos factuelles.",
    instruction="""Tu es un chercheur factuel. Réponds en 3 phrases maximum.
    Cite toujours une source quand tu peux."""
)

Test :

from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService

runner = Runner(agent=recherche_agent, session_service=InMemorySessionService())
session = runner.session_service.create_session(app_name="demo", user_id="eric")

async for event in runner.run_async(
    user_id="eric",
    session_id=session.id,
    new_message="Quel est le PIB de la France en 2025 ?"
):
    print(event)

Lance python agent_base.py. Tu vois un flux d’événements avec la réponse. C’est ton premier agent en 10 lignes.

Étape 3 — Ajoute un outil (10 minutes)

Un agent qui ne fait que chatter, ça va deux minutes. Les vrais agents appellent des outils. On ajoute une calculatrice :

def calculer(expression: str) -> dict:
    """Évalue une expression mathématique simple.
    Retourne un dict avec le résultat."""
    try:
        result = eval(expression, {"__builtins__": {}})
        return {"result": result, "status": "ok"}
    except Exception as e:
        return {"result": None, "status": "error", "message": str(e)}

recherche_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    tools=[calculer],
    instruction="Tu réponds aux questions. Utilise calculer() pour toute maths."
)

Tu poses « Combien fait 842 × 37 » et l’agent appelle calculer("842 * 37"). Tu peux brancher n’importe quelle fonction Python comme outil : une API météo, une requête SQL, un appel interne à ton système d’info.

Étape 4 — Le vrai multi-agent (20 minutes)

Maintenant le morceau intéressant. On construit trois agents qui collaborent : un routeur qui reçoit la requête, un spécialiste maths et un spécialiste texte. Crée agent_team.py :

from google.adk.agents import LlmAgent
from dotenv import load_dotenv
load_dotenv()

def calculer(expression: str) -> dict:
    try:
        return {"result": eval(expression, {"__builtins__": {}}), "status": "ok"}
    except Exception as e:
        return {"status": "error", "message": str(e)}

maths_agent = LlmAgent(
    name="math_expert",
    model="gemini-2.0-flash",
    description="Expert en maths. Résout des calculs et explique la démarche.",
    tools=[calculer],
    instruction="Tu es mathématicien. Utilise calculer() pour toute opération."
)

texte_agent = LlmAgent(
    name="text_expert",
    model="gemini-2.0-flash",
    description="Expert en rédaction, résumé, traduction.",
    instruction="Tu rédiges de manière claire et concise."
)

router = LlmAgent(
    name="router",
    model="gemini-2.0-flash",
    description="Oriente la requête vers l'expert approprié.",
    sub_agents=[maths_agent, texte_agent],
    instruction="""Tu orientes chaque requête vers le bon sous-agent.
    - Maths, calculs, statistiques -> math_expert
    - Rédaction, résumé, traduction -> text_expert
    Délègue sans répondre toi-même."""
)

Tu as trois agents, une hiérarchie claire, et la délégation se fait automatiquement. Teste avec deux requêtes :

new_message="Résume en 2 phrases : 'Le chat dort sur le canapé...'"
new_message="Combien fait la racine carrée de 4 356 ?"

Tu verras le routeur appeler le bon spécialiste à chaque fois. C’est ça, le multi-agent d’ADK : une composition simple qui scale.

Étape 5 — Sandbox Code Executor (15 minutes)

Les nouvelles features 2026 d’ADK incluent AgentEngineSandboxCodeExecutor. Elle permet d’exécuter du code Python généré par l’agent dans un sandbox sécurisé Vertex AI. Utile quand tu veux qu’un agent fasse du data crunching, crée des graphiques ou manipule des fichiers.

from google.adk.code_executors import AgentEngineSandboxCodeExecutor

data_agent = LlmAgent(
    name="data_analyst",
    model="gemini-2.0-flash",
    description="Analyste de données Python.",
    code_executor=AgentEngineSandboxCodeExecutor(),
    instruction="Tu génères et exécutes du code Python pour analyser des données."
)

Tu lui donnes un CSV en entrée, il écrit du Pandas, le sandbox l’exécute et te renvoie le résultat. Gros gain par rapport aux LLM qui se contentent de générer du code sans le tester.

Étape 6 — Déploiement Cloud Run (20 minutes)

Ton agent tourne en local, c’est bien. Mais en vrai tu veux l’appeler depuis une app web, un bot Slack ou un cron. Cloud Run est la cible la plus simple.

Prérequis : installe gcloud CLI, connecte-toi avec gcloud auth login, choisis un projet avec gcloud config set project TON-PROJET.

ADK te fournit une commande magique :

adk deploy cloud-run ./mon-agent 
    --service-name mon-premier-agent 
    --region europe-west1 
    --allow-unauthenticated

La commande construit une image Docker, pousse sur Artifact Registry, déploie sur Cloud Run et te retourne une URL HTTPS. Tu peux maintenant appeler ton agent par curl :

curl -X POST https://mon-premier-agent-xyz.a.run.app/run 
    -H "Content-Type: application/json" 
    -d '{"message": "Résume l'actualité IA"}'

Pour la prod, retire --allow-unauthenticated et utilise IAM + comptes de service. Le coût Cloud Run est quasi-nul à faible trafic : tu payes à la requête et à la seconde d’exécution.

Coûts réels pour un petit projet

Pour un side-project, tu peux viser quasi-gratuit pendant les premiers mois. Gemini 1.5 Flash en free tier te donne 1 500 requêtes gratuites par jour. Cloud Run offre 2 millions de requêtes gratuites par mois. Si tu sors de ces bornes, compte environ 0,35 $ pour 1 000 requêtes (Gemini) et 0,40 $ pour 1 million de requêtes Cloud Run. Tu passes facilement sous 10 $/mois pour un produit qui reçoit quelques milliers de requêtes par jour.

Erreurs courantes et comment les éviter

Trois pièges classiques. Premier piège : l’agent boucle indéfiniment parce que les sous-agents s’appellent en cercle. Solution : mets max_iterations=5 sur ton runner. Deuxième piège : ta clé API Gemini fuite dans les logs. Solution : utilise Google Secret Manager en prod, jamais les variables d’env en dur. Troisième piège : tu passes tout en mémoire (InMemorySessionService) et ça explose en prod. Solution : utilise VertexAiSessionService ou DatabaseSessionService.

Ce que tu peux faire ensuite

Cinq extensions naturelles pour aller plus loin. Un agent qui lit ta boîte mail et trie les messages importants, via l’API Gmail. Un assistant de veille qui surveille Hacker News et te résume les threads pertinents. Un bot Slack qui répond aux questions RH de tes collègues sur une base de connaissances interne. Un agent de support client qui qualifie les tickets avant de les router. Un générateur de rapports hebdomadaires qui interroge ta base PostgreSQL et produit un Markdown lisible.

Dans chaque cas, tu gardes la même structure : un router, N spécialistes, des outils qui parlent à ton SI. La différence se fait dans la qualité des instructions — passe du temps à les écrire, teste, itère.

Monitoring et traces en production

Un agent qui tourne sans observabilité est un agent qui explose en silence. ADK s’intègre avec trois systèmes qui t’évitent les mauvaises surprises. Le premier est Cloud Trace, automatique dès que tu déploies sur Cloud Run : tu vois le graphe d’appel entre tes agents, les durées de chaque appel LLM, les retries. Deuxième outil : Vertex AI Eval, qui te laisse scorer tes réponses sur un jeu de données de référence (précision, pertinence, toxicité). Troisième outil : Arize Phoenix, open-source, qui s’active en deux lignes Python et qui te sort des heatmaps de coût et de latence par agent.

Mon conseil concret : mets en place Cloud Trace dès le premier déploiement, ajoute Arize Phoenix à la deuxième semaine. Vertex AI Eval vient plus tard, quand tu as assez de données pour créer un jeu de test pertinent. Sans monitoring, tu vas découvrir qu’un agent coûte 20 fois plus cher que prévu le jour de la facture.

Tests automatisés pour ton agent

Les agents se testent, eux aussi. Trois patterns valent l’investissement. Premier pattern : les assertions sur les outils appelés. Tu testes que, face à la question « Combien fait 5 × 12 ? », l’agent appelle bien calculer("5*12") et pas un autre outil. Deuxième pattern : les tests de régression sur un jeu de 20 à 50 questions typiques, où tu mesures la cohérence des réponses à chaque release. Troisième pattern : les tests adversariaux, où tu essaies de casser l’agent avec des prompts piégés (injection, prompt leakage, sorties hors sujet).

ADK fournit un module google.adk.testing qui facilite ces trois patterns. Il te donne un client de test qui mocke les LLM avec des réponses pré-enregistrées, ce qui permet de faire tourner la suite en CI sans brûler de tokens. Le coût d’une CI hebdomadaire devient négligeable.

Facturation détaillée et seuils à surveiller

Trois lignes de facturation à monitorer chaque semaine. D’abord, la facture Gemini (ou le fournisseur LLM choisi) : regarde le coût par 1 000 requêtes et le ratio input/output tokens. Si tu dépasses 0,50 $/1 000 requêtes sans avoir migré sur un modèle premium, il y a une fuite quelque part (prompts trop longs, boucles non stoppées). Ensuite, la facture Cloud Run : elle doit rester sous 10 $/mois tant que tu es sous 10 000 requêtes quotidiennes. Au-dessus, envisage les instances réservées. Enfin, la facture Cloud Trace : elle reste quasi-nulle en usage normal mais peut exploser si tu traces des réponses volumineuses en entier.

Mon réflexe : une alerte budget Google Cloud à 30 $/mois au démarrage, relevée progressivement au fil de l’adoption. Ça te sauve des factures à 500 $ qui arrivent un vendredi soir.

Ressources pour progresser

La documentation officielle google.github.io/adk-docs est à jour et couvre tous les cas. Le dépôt google/adk-samples contient une trentaine d’exemples réels, du chatbot simple au pipeline d’analyse de données. Pour le déploiement multi-agent avec A2A (Agent-to-Agent protocol), le billet de blog Google Cloud Community d’avril 2026 couvre le pattern complet avec Gemini CLI.

Côté communauté, le Discord Google Developers a un canal #adk-help plutôt actif. Les issues GitHub sont traitées sous 48 à 72h par l’équipe Google.

Bilan

En 90 minutes, tu es passé de zéro à un système multi-agent qui tourne en production. C’est rare dans l’écosystème des frameworks IA. Ce que j’apprécie dans ADK : la simplicité API, la compatibilité multi-LLM (tu peux migrer Gemini vers Claude en changeant une ligne), et l’intégration Cloud Run sans friction.

Si tu débutes avec les agents, démarre par ADK. Si tu viens de LangChain et que ça te fatigue, bascule sur ADK. Si tu cherches du ultra-léger, regarde aussi Hugging Face smolagents — mais tu sacrifieras la partie déploiement clé-en-main.

À toi de jouer. Quand tu as un premier agent qui tourne, envoie-moi le lien, je regarde avec plaisir.

Pour aller plus loin : fais tourner un agent IA local sur ton Mac et le guide OpenAI Frontier pour déployer des agents.

Articles similaires

Guides

Agent IA en PME : 7 étapes pour éviter la surcharge 77 %

avril 23, 2026

Guides

Devenir prompt engineer en France 2026 : 6 étapes, 40-110K€

avril 22, 2026

Guides

Meilleur LLM local 2026 : lequel tourne sur votre PC ?

avril 21, 2026