Guide complet Google ADK 2026 : Construisez des agents IA intelligents avec du code

Qu'est-ce que Google ADK ?

Google ADK (Agent Development Kit) est un framework de développement d'agents IA open source conçu par Google pour les développeurs qui souhaitent intégrer des agents IA dans des applications réelles. Contrairement à des frameworks comme LangChain ou LlamaIndex, l'ADK adopte une approche « code-first » (code en priorité), rendant le comportement des agents aussi prévisible et testable que celui des logiciels traditionnels.

Fonctionnalités principales

Code en priorité : Définissez le comportement des agents en Python pur, sans configurations YAML complexes
Sécurité de type : Tire pleinement parti des annotations de type Python, offrant l'auto-complétion IDE et la vérification des erreurs
Testabilité : La logique des agents peut être testée unitairement comme des fonctions ordinaires
Prêt pour la production : Intègre la journalisation, la surveillance, la gestion des erreurs et autres fonctionnalités essentielles en production
Support multi-modèles : Prend en charge Gemini, GPT-4, Claude et autres grands modèles de langage principaux

Cas d'utilisation

Chatbots de service client
Assistants d'automatisation des flux de travail
Analyse de données et génération de rapports
Révision de code et aide à la programmation
Systèmes de questions-réponses sur les connaissances internes des entreprises

Installation et configuration

Prérequis

Python 3.10 ou version supérieure
Gestionnaire de paquets pip
Compte Google Cloud (lors de l'utilisation du modèle Gemini)

Étapes d'installation

# Créer un environnement virtuel (recommandé)
python3 -m venv adk-env
source adk-env/bin/activate  # Linux/macOS
# adk-env\Scripts\activate  # Windows

# Installer Google ADK
pip install google-adk

# Installer des dépendances supplémentaires (selon les besoins)
pip install google-adk[cli]  # Inclut les outils en ligne de commande
pip install google-adk[testing]  # Inclut les outils de test

Configuration de la clé API

# Méthode 1 : Utiliser les variables d'environnement (recommandé pour le développement)
export GEMINI_API_KEY="your-api-key-here"

# Méthode 2 : Utiliser le fichier d'identifiants Google Cloud
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"

# Méthode 3 : Configuration directe dans le code (non recommandé pour la production)

Concepts fondamentaux

1. Agent (Agent intelligent)

L'agent est le composant central de l'ADK, responsable de la réception des entrées utilisateur, de l'appel d'outils et de la génération de réponses.

from google.adk import Agent
from google.adk.models import Gemini

# Créer un agent de base
agent = Agent(
    name="customer_support",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Vous êtes un assistant de service professionnel qui aide les utilisateurs à résoudre les problèmes de produits.",
)

2. Tools (Outils)

Les outils sont des fonctions externes que l'agent peut appeler pour exécuter des tâches spécifiques.

from google.adk import Tool
from google.adk.tools import FunctionTool

# Définir une fonction outil
def search_knowledge_base(query: str) -> str:
    """Rechercher des informations pertinentes dans la base de connaissances"""
    # L'implémentation réelle peut appeler une base de données ou une API
    return f"Résultats de la recherche '{query}'..."

# Créer l'outil
search_tool = FunctionTool(
    func=search_knowledge_base,
    name="search_kb",
    description="Rechercher dans la base de connaissances produits",
)

# Ajouter l'outil à l'agent
agent.tools = [search_tool]

3. Sessions (Sessions)

Les sessions gèrent l'historique des interactions entre l'utilisateur et l'agent, prenant en charge les conversations multi-tours.

from google.adk import Session

# Créer une session
session = Session(
    agent=agent,
    user_id="user_123",
)

# Envoyer un message
response = await session.send("Mon produit ne démarre pas, que faire ?")
print(response.text)

4. Events (Événements)

Le système d'événements prend en charge le traitement asynchrone des messages et les réponses en streaming.

from google.adk import Event

async def handle_event(event: Event):
    if event.type == "user_message":
        response = await session.send(event.content)
        await event.reply(response.text)

Exemples pratiques

Exemple 1 : Robot de questions-réponses simple

from google.adk import Agent, Session, Runner
from google.adk.models import Gemini

# Créer l'agent
agent = Agent(
    name="faq_bot",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="""Vous êtes un robot FAQ qui répond aux questions sur les produits.
    - Gardez les réponses concises et claires
    - Si vous ne connaissez pas la réponse, dites-le honnêtement
    - Fournissez des conseils d'aide pertinents""",
)

# Exécuter une session interactive
async def main():
    runner = Runner(agent=agent)
    await runner.run_interactive()

# python3 faq_bot.py

Exemple 2 : Assistant d'analyse de données avec outils

from google.adk import Agent, Tool
from google.adk.tools import FunctionTool
from google.adk.models import Gemini
import pandas as pd

# Définir les outils d'analyse de données
def load_csv(file_path: str) -> dict:
    """Charger un fichier CSV et retourner les informations de base"""
    df = pd.read_csv(file_path)
    return {
        "rows": len(df),
        "columns": list(df.columns),
        "dtypes": df.dtypes.astype(str).to_dict(),
    }

def calculate_stats(file_path: str, column: str) -> dict:
    """Calculer les statistiques pour une colonne spécifiée"""
    df = pd.read_csv(file_path)
    numeric_col = pd.to_numeric(df[column], errors="coerce")
    return {
        "mean": float(numeric_col.mean()),
        "median": float(numeric_col.median()),
        "std": float(numeric_col.std()),
        "min": float(numeric_col.min()),
        "max": float(numeric_col.max()),
    }

# Créer les outils
tools = [
    FunctionTool(func=load_csv, name="load_csv", description="Charger un fichier CSV"),
    FunctionTool(func=calculate_stats, name="calc_stats", description="Calculer les statistiques"),
]

# Créer l'agent
agent = Agent(
    name="data_analyst",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Vous êtes un assistant d'analyse de données, aidant les utilisateurs à analyser des fichiers de données CSV.",
    tools=tools,
)

Exemple 3 : Système de collaboration multi-agents

from google.adk import Agent, Runner
from google.adk.models import Gemini

# Créer plusieurs agents spécialisés
researcher = Agent(
    name="researcher",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Vous êtes responsable de la collecte et de la recherche d'informations, fournissant des faits et des données détaillés.",
)

writer = Agent(
    name="writer",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Vous êtes responsable de l'organisation des résultats de recherche en rapports structurés et lisibles.",
)

reviewer = Agent(
    name="reviewer",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Vous êtes responsable de la vérification de la qualité des rapports, assurant l'exactitude et l'exhaustivité.",
)

# Orchestrer plusieurs agents avec un flux de travail
async def collaborative_workflow(user_query: str):
    # Phase de recherche
    research_result = await researcher.run(user_query)

    # Phase de rédaction
    draft = await writer.run(f"Rédiger un rapport basé sur les résultats de recherche suivants : {research_result}")

    # Phase de révision
    final_report = await reviewer.run(f"Vérifier et améliorer le rapport suivant : {draft}")

    return final_report

Fonctionnalités avancées

Réponses en streaming

from google.adk import Agent, Session
from google.adk.models import Gemini

agent = Agent(
    name="streaming_bot",
    model=Gemini(model="gemini-2.0-flash"),
)

session = Session(agent=agent)

# Traiter la réponse en streaming
async for chunk in session.send_stream("Racontez une histoire sur l'IA"):
    print(chunk.text, end="", flush=True)

Middleware personnalisé

from google.adk import Middleware

class LoggingMiddleware(Middleware):
    """Middleware de journalisation, enregistrant toutes les requêtes et réponses"""

    async def on_request(self, request):
        print(f"[REQUEST] {request.user_id}: {request.content}")
        return request

    async def on_response(self, response):
        print(f"[RESPONSE] {response.text[:100]}...")
        return response

# Ajouter le middleware
agent.middleware = [LoggingMiddleware()]

Gestion des erreurs et nouvelles tentatives

from google.adk import Agent
from google.adk.models import Gemini
from google.adk.retry import RetryConfig

agent = Agent(
    name="robust_bot",
    model=Gemini(model="gemini-2.0-flash"),
    retry_config=RetryConfig(
        max_retries=3,
        retry_delay=1.0,
        retry_on=[TimeoutError, ConnectionError],
    ),
)

Meilleures pratiques

1. Ingénierie de prompts

# Bonne pratique : instructions claires et précises
agent = Agent(
    instruction="""Vous êtes un assistant de support technique professionnel.

    Règles de réponse :
    1. Confirmez d'abord la compréhension du problème de l'utilisateur
    2. Fournissez des solutions étape par étape
    3. Si le problème est complexe, suggérez de contacter le support humain
    4. Maintenez un ton amical et professionnel""",
)

# À éviter : instructions vagues et génériques
agent = Agent(
    instruction="Aider l'utilisateur à résoudre son problème",  # Trop vague
)

2. Conception d'outils

# Bonne pratique : responsabilité unique, documentation claire
def get_order_status(order_id: str) -> dict:
    """
    Vérifier le statut d'une commande

    Args:
        order_id: Numéro de commande (format : ORD-XXXXXX)

    Returns:
        Dictionnaire contenant status, estimated_delivery, etc.
    """
    pass

# À éviter : multifonction, trop de paramètres
def handle_order(action: str, order_id: str, user_id: str, 
                 items: list, address: dict, payment: dict) -> dict:
    # Trop complexe, difficile à maintenir
    pass

3. Stratégie de test

import pytest
from google.adk import Agent, Session

@pytest.fixture
def test_agent():
    return Agent(
        name="test_bot",
        model=Gemini(model="gemini-2.0-flash"),
        instruction="Vous êtes un assistant de test",
    )

@pytest.mark.asyncio
async def test_agent_response(test_agent):
    session = Session(agent=test_agent)
    response = await session.send("Bonjour")
    assert response.text is not None
    assert len(response.text) > 0

4. Optimisation des performances

# Utiliser un pool de connexions
from google.adk.models import Gemini

model = Gemini(
    model="gemini-2.0-flash",
    max_concurrent_requests=10,
    timeout=30.0,
)

# Mettre en cache les réponses fréquentes
from functools import lru_cache

@lru_cache(maxsize=100)
def get_faq_answer(question_hash: str) -> str:
    # Logique de cache
    pass

Guide de déploiement

Serveur de développement local

from google.adk import Agent, Runner
from google.adk.models import Gemini

agent = Agent(
    name="web_bot",
    model=Gemini(model="gemini-2.0-flash"),
)

# Démarrer le serveur Web
runner = Runner(agent=agent)
runner.serve(host="0.0.0.0", port=8000)

# Accéder à http://localhost:8000

Déploiement Docker

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "main.py"]

Google Cloud Run

# cloud-run.yaml
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: adk-agent
spec:
  template:
    spec:
      containers:
      - image: gcr.io/your-project/adk-agent
        env:
        - name: GEMINI_API_KEY
          valueFrom:
            secretKeyRef:
              name: api-keys
              key: gemini

Questions fréquemment posées

Q1 : Quelle est la différence entre ADK et LangChain ?

R : L'ADK met l'accent sur le code en priorité et la sécurité de type, adapté aux développeurs ayant une expérience en programmation ; LangChain offre des composants préconstruits plus riches et des configurations YAML, idéal pour le prototypage rapide.

Q2 : Quels grands modèles de langage sont pris en charge ?

R : Prise en charge native des modèles de la famille Google Gemini. Via des fournisseurs personnalisés, vous pouvez également intégrer OpenAI GPT, Anthropic Claude, des modèles locaux, etc.

Q3 : Comment déboguer le comportement de l'agent ?

R : Utilisez le mode de débogage intégré de l'ADK :

from google.adk import Runner

runner = Runner(agent=agent, debug=True)
# Les journaux détaillés seront affichés dans la console

Q4 : Que faut-il prendre en compte pour l'environnement de production ?

R : - Utiliser les variables d'environnement pour gérer les clés API - Configurer des limites de taux appropriées - Implémenter la journalisation et la surveillance - Ajouter la gestion des erreurs et les mécanismes de nouvelle tentative - Effectuer des tests de charge approfondis

Résumé

Google ADK offre aux développeurs un outil puissant et flexible pour construire des applications d'agents IA prêtes pour la production. Son approche de conception code-first rapproche le développement d'agents des pratiques de génie logiciel traditionnelles, facilitant les tests, la maintenance et l'extension.

Prochains pas

Lire la documentation officielle
Consulter le répertoire d'exemples GitHub
Rejoindre la communauté de développeurs
Essayer de construire votre premier projet Agent

Ressources associées :