Tutoriel Google ADK : Créer des agents IA de zéro à la production

Tutoriel Google ADK : Créer des agents IA de zéro à la production

Le Google Agent Development Kit (ADK) est le framework qui rend enfin les systèmes multi-agents accessibles. Si vous avez construit des agents IA avec LangChain ou CrewAI et que vous aviez l'impression de combattre le framework plutôt que de construire avec lui, ce tutoriel Google ADK vous guide à travers tout -- de votre premier agent jusqu'au déploiement sur Cloud Run.

Qu'est-ce que Google ADK (et pourquoi s'y intéresser) ?

Le Google Agent Development Kit (ADK) est un framework Python open source pour créer, évaluer et déployer des agents IA. Publié en 2025, il est optimisé pour Gemini mais supporte plus de 100 modèles via LiteLLM. La fonctionnalité phare d'ADK est l'orchestration multi-agents native -- des agents qui délèguent des tâches à d'autres agents sans code intermédiaire.

Après avoir construit des agents avec LangChain, CrewAI et maintenant ADK, voici ce qui se démarque : ADK est opiniâtre aux bons endroits. Il vous donne une structure de projet, une interface de développement intégrée et une commande de déploiement. Vous n'avez pas besoin d'assembler cinq bibliothèques pour faire tourner un agent de base.

Si LangChain est un couteau suisse polyvalent, ADK est la boîte à outils de Google conçue spécifiquement pour les workflows multi-agents. CrewAI est philosophiquement plus proche -- des agents basés sur des rôles qui collaborent -- mais ADK va plus loin avec une évaluation intégrée, une optimisation Gemini native et un déploiement Cloud Run en une seule commande. Pour une analyse approfondie, consultez notre comparatif détaillé des frameworks d'agents.

À qui s'adresse ADK ? Aux développeurs Python qui veulent des systèmes multi-agents structurés. Aux équipes déjà sur Google Cloud ou Gemini. À quiconque en a assez d'écrire du code d'orchestration redondant.

Voici comment les frameworks se comparent en un coup d'œil :

En résumé : si vous voulez le chemin le plus rapide d'une « idée » à un « système multi-agents déployé », ADK est difficile à battre en ce moment.

Prérequis et installation de Google ADK

Pour démarrer avec Google ADK, vous avez besoin de Python 3.9+, d'une clé API Gemini (niveau gratuit disponible sur Google AI Studio) et du paquet google-adk. Installez avec pip install google-adk, définissez votre clé API comme variable d'environnement, et vous êtes prêt à créer votre premier agent en moins de 5 minutes.

Voici votre liste de contrôle d'installation :

• Python 3.9+ (3.10+ recommandé pour la prise en charge complète des annotations de type)
• Une clé API Gemini -- obtenez-en une gratuitement sur aistudio.google.com. Le niveau gratuit vous donne 15 requêtes par minute, largement suffisant pour le développement.
• pip (ou uv si vous préférez la vitesse -- uv pip install google-adk fonctionne aussi)

Installez le paquet et définissez votre clé :

pip install google-adk

# Définissez votre clé API (ajoutez à .bashrc/.zshrc pour la persistance)
export GOOGLE_API_KEY="your-api-key-here"

ADK attend une structure de dossiers spécifique. Chaque agent vit dans son propre répertoire de paquet :

my_agent/
  __init__.py    # Exporte root_agent
  agent.py       # Définition de l'agent
.env             # Optionnel : GOOGLE_API_KEY=your-key

Le nom du dossier devient le nom de paquet de votre agent, donc choisissez quelque chose de descriptif. N'appelez pas ça test ou agent -- vous allez perturber le système d'import de Python.

Conseil pro : Si vous utilisez uv, créez d'abord un environnement virtuel avec uv venv && source .venv/bin/activate. C'est nettement plus rapide que pip classique pour la résolution des dépendances.

Créer votre premier agent Google ADK

Votre premier agent ADK n'a besoin que de trois choses : un nom, un modèle (comme gemini-2.0-flash) et une chaîne d'instructions. Définissez-le dans agent.py, placez-le dans un dossier avec un __init__.py, et lancez adk web pour discuter avec lui dans une interface navigateur. L'installation complète prend environ 10 lignes de Python.

Créez un dossier appelé my_agent et ajoutez deux fichiers. D'abord, la définition de l'agent :

# my_agent/agent.py
from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="my_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful coding assistant. 
    You explain concepts clearly and provide working code examples.
    Keep responses concise but thorough.""",
    description="A coding assistant that explains concepts and writes code"
)

Puis le fichier init qui exporte votre agent :

# my_agent/__init__.py
from .agent import root_agent

Ce nom de variable est important -- ADK recherche spécifiquement root_agent. Si vous le manquez, vous obtiendrez une erreur « agent not found » qui n'explique pas pourquoi.

Maintenant, lancez-le. Vous avez deux options :

# Mode CLI -- discutez dans votre terminal
adk run my_agent

# Mode interface web -- ouvre une interface navigateur
adk web my_agent

L'interface adk web est vraiment utile. Elle vous montre la trace complète de la conversation, les outils appelés par l'agent, ce que le modèle a reçu et ce qu'il a retourné. Pensez-y comme aux DevTools de Chrome pour votre agent. Quand vous commencerez à construire des systèmes multi-agents, cela devient indispensable pour comprendre le flux de délégation.

Essayez de modifier les instructions pour voir comment le comportement change. Faites-en un pirate. Faites-le répondre uniquement en haïku. Comprendre comment les instructions façonnent le comportement est la base de tout le reste dans ce tutoriel.

Ajouter des outils personnalisés à votre agent Google ADK

Les agents ADK deviennent utiles quand vous leur donnez des outils. Définissez une fonction Python avec une docstring claire, et ADK la convertit automatiquement en outil que l'agent peut appeler. La docstring est cruciale -- elle indique au modèle ce que fait l'outil et quand l'utiliser. ADK intègre aussi des outils prêts à l'emploi comme Google Search et l'exécution de code.

Les outils sont les mains d'un agent. Sans eux, votre agent ne peut que parler. Avec eux, il peut interroger des bases de données, appeler des API, effectuer des calculs et interagir avec des systèmes externes. Si vous voulez comprendre comment fonctionne le function calling en détail, nous avons une analyse approfondie dédiée à ce sujet.

Outils de fonction personnalisés

Voici un exemple concret -- un outil qui recherche des cours de bourse :

# my_agent/agent.py
from google.adk.agents import LlmAgent

def get_stock_price(ticker: str) -> dict:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: The stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT')
    
    Returns:
        A dictionary with the ticker and its current price.
    """
    # En production, vous appelleriez une vraie API ici
    mock_prices = {"AAPL": 198.50, "GOOGL": 175.20, "MSFT": 425.80}
    price = mock_prices.get(ticker.upper(), None)
    if price:
        return {"ticker": ticker.upper(), "price": price, "currency": "USD"}
    return {"error": f"Ticker {ticker} not found"}

root_agent = LlmAgent(
    name="finance_assistant",
    model="gemini-2.0-flash",
    instruction="You help users check stock prices. Use the get_stock_price tool when asked about any stock.",
    tools=[get_stock_price],
    description="A financial assistant that looks up stock prices"
)

Notez les annotations de type et la docstring. Ce ne sont pas de simples fioritures -- ADK les utilise pour générer le schéma d'outil que le modèle voit. Omettez la docstring et le modèle ne saura pas quand appeler votre fonction. Omettez les annotations de type et vous obtiendrez une erreur de signature.

Outils intégrés (Google Search, exécution de code)

ADK intègre des outils que vous pouvez utiliser sans écrire une seule ligne de code :

from google.adk.agents import LlmAgent
from google.adk.tools import google_search, code_execution

root_agent = LlmAgent(
    name="research_agent",
    model="gemini-2.0-flash",
    instruction="You research topics using Google Search and can run Python code to analyze data.",
    tools=[google_search, code_execution],
    description="A research agent with search and code execution capabilities"
)

google_search permet à l'agent d'interroger le web en temps réel. code_execution lui fournit un environnement Python isolé pour effectuer des calculs. Ces deux outils à eux seuls couvrent un nombre surprenant de cas d'usage.

Systèmes multi-agents : comment les agents Google ADK délèguent le travail

Le système multi-agents d'ADK utilise un agent racine qui délègue des tâches à des sous-agents spécialisés. Chaque sous-agent gère un domaine -- recherche, rédaction, programmation. L'agent racine décide quel sous-agent appeler en fonction de la demande de l'utilisateur. Vous pouvez aussi utiliser le pattern agent-comme-outil, où un agent appelle un autre comme s'il était une fonction. Le blog officiel de Google sur les systèmes multi-agents approfondit les patterns architecturaux.

Imaginez un chef de projet qui délègue à des spécialistes. L'agent racine lit la demande de l'utilisateur, détermine quel spécialiste doit la traiter, et redirige en conséquence. Les spécialistes ne se connaissent pas -- ils font simplement leur travail et rendent compte.

Pattern agent racine + sous-agents

Voici un exemple fonctionnel avec un agent racine qui délègue à un agent de recherche et un agent de rédaction :

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

# Sous-agent 1 : gère la recherche
research_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="You research topics thoroughly using Google Search. Return factual, well-sourced information.",
    tools=[google_search],
    description="Researches topics and returns factual information"
)

# Sous-agent 2 : gère la rédaction
writing_agent = LlmAgent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="You write clear, engaging content based on provided information. Focus on readability and accuracy.",
    description="Writes polished content from research notes"
)

# Agent racine : délègue au bon sous-agent
root_agent = LlmAgent(
    name="content_manager",
    model="gemini-2.0-flash",
    instruction="""You manage content creation. 
    - When the user wants information gathered, delegate to the researcher.
    - When the user wants content written or edited, delegate to the writer.
    - You can chain both: research first, then write.""",
    sub_agents=[research_agent, writing_agent],
    description="Manages content creation by delegating to research and writing specialists"
)

Le champ description de chaque sous-agent est la manière dont l'agent racine comprend ce qu'ils peuvent faire. Rédigez des descriptions claires -- des descriptions vagues mènent à de mauvaises décisions de routage.

Pattern agent-comme-outil

Parfois vous voulez plus de contrôle sur la façon dont un agent appelle un autre. Le pattern agent-comme-outil enveloppe un sous-agent comme un outil appelable :

from google.adk.tools import agent_tool

research_tool = agent_tool.AgentTool(agent=research_agent)

root_agent = LlmAgent(
    name="writer_with_research",
    model="gemini-2.0-flash",
    instruction="You write articles. Use the research tool to gather facts before writing.",
    tools=[research_tool],
    description="A writer that can research topics on demand"
)

Utilisez les sous-agents quand vous voulez que l'agent racine délègue entièrement le contrôle. Utilisez agent-comme-outil quand vous voulez que l'agent appelant reste aux commandes et utilise simplement la sortie du sous-agent comme entrée. Si vous construisez des systèmes où les agents ont besoin d'un contexte partagé, consultez notre guide complet sur les architectures de mémoire pour agents.

Agents de workflow : séquentiel, parallèle et en boucle

Au-delà de la délégation pilotée par LLM, ADK propose trois types d'agents de workflow pour une orchestration déterministe : SequentialAgent exécute les sous-agents les uns après les autres, ParallelAgent les exécute simultanément, et LoopAgent répète une séquence jusqu'à ce qu'une condition soit remplie. Ces agents sont utiles quand vous avez besoin d'un ordre d'exécution prévisible plutôt que de laisser le LLM décider.

La distinction compte. La délégation pilotée par LLM (le pattern sub_agents ci-dessus) laisse le modèle choisir qui appeler. Les agents de workflow vous donnent un contrôle programmatique. Utilisez les agents de workflow quand l'ordre d'exécution est connu à l'avance.

from google.adk.agents import SequentialAgent, ParallelAgent, LlmAgent

# Trois agents qui doivent s'exécuter dans l'ordre
research_agent = LlmAgent(name="researcher", model="gemini-2.0-flash",
    instruction="Research the given topic.", description="Researches topics")
    
draft_agent = LlmAgent(name="drafter", model="gemini-2.0-flash",
    instruction="Write a draft based on the research.", description="Writes drafts")
    
review_agent = LlmAgent(name="reviewer", model="gemini-2.0-flash",
    instruction="Review the draft for accuracy and clarity.", description="Reviews content")

# Pipeline : recherche -> rédaction -> révision
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Pour les tâches indépendantes pouvant s'exécuter en même temps, ParallelAgent fait gagner un temps réel :

# Trois récupérateurs de données qui s'exécutent en parallèle
fetch_news = LlmAgent(name="news_fetcher", model="gemini-2.0-flash",
    instruction="Fetch latest tech news.", description="Fetches news")
    
fetch_stocks = LlmAgent(name="stock_fetcher", model="gemini-2.0-flash",
    instruction="Fetch stock market summary.", description="Fetches stocks")
    
fetch_weather = LlmAgent(name="weather_fetcher", model="gemini-2.0-flash",
    instruction="Fetch weather forecast.", description="Fetches weather")

morning_briefing = ParallelAgent(
    name="morning_briefing",
    sub_agents=[fetch_news, fetch_stocks, fetch_weather],
    description="Gathers morning briefing data in parallel"
)

Gérer l'état et la mémoire

ADK gère l'état des agents à deux niveaux : l'état de session (données au sein d'une conversation, comme les préférences utilisateur collectées en cours de discussion) et les services de mémoire (données persistant entre les conversations). L'état de session est un simple magasin clé-valeur accessible via context.state. La mémoire utilise des services comme InMemoryMemoryService ou VertexAIMemoryBankService pour la production.

L'état de session est le plus simple. C'est un dictionnaire attaché à chaque conversation :

from google.adk.agents import LlmAgent

def save_preference(key: str, value: str, context) -> str:
    """Save a user preference to session state.
    
    Args:
        key: The preference name (e.g., 'language', 'theme')
        value: The preference value
        context: The ADK context object
    
    Returns:
        Confirmation message
    """
    context.state[key] = value
    return f"Saved preference: {key} = {value}"

def get_preference(key: str, context) -> str:
    """Retrieve a user preference from session state.
    
    Args:
        key: The preference name to look up
        context: The ADK context object
    
    Returns:
        The preference value or a not-found message
    """
    value = context.state.get(key, "Not set")
    return f"{key} = {value}"

root_agent = LlmAgent(
    name="personalized_assistant",
    model="gemini-2.0-flash",
    instruction="You remember user preferences. Save them when told, recall them when asked.",
    tools=[save_preference, get_preference],
    description="An assistant that remembers user preferences"
)

Pour la mémoire inter-conversations -- le genre où votre agent se souvient d'un utilisateur du mardi dernier -- vous avez besoin d'un service de mémoire :

from google.adk.memory import InMemoryMemoryService

# Pour le développement (données perdues au redémarrage)
memory_service = InMemoryMemoryService()

# Pour la production, utilisez VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Quand faut-il utiliser la mémoire plutôt que l'état de session ? Si c'est au sein d'une seule conversation (panier d'achat, contexte de tâche en cours), utilisez l'état de session. Si cela doit survivre entre les conversations (préférences utilisateur, interactions passées), utilisez un service de mémoire. Consultez notre guide complet sur les architectures de mémoire pour agents pour les patterns de production.

Callbacks : contrôler le comportement des agents

Les callbacks ADK vous permettent d'intercepter et de modifier le comportement des agents en quatre points : before_model_callback (avant l'appel LLM), after_model_callback (après la réponse LLM), before_tool_callback (avant l'exécution d'un outil) et after_tool_callback (après le résultat de l'outil). Utilisez-les pour la validation des entrées, le filtrage de sécurité, la journalisation ou la modification des réponses avant qu'elles n'atteignent l'utilisateur.

Les callbacks sont là où vous ajoutez des garde-fous. Considérez-les comme un middleware pour votre agent -- chaque requête et réponse les traverse, et vous pouvez inspecter, modifier ou bloquer n'importe quoi.

from google.adk.agents import LlmAgent

def safety_filter(callback_context, llm_request):
    """Block requests containing harmful content patterns."""
    user_message = str(llm_request)
    blocked_patterns = ["ignore your instructions", "pretend you are"]
    
    for pattern in blocked_patterns:
        if pattern.lower() in user_message.lower():
            # Retourner une réponse directement, en ignorant l'appel au modèle
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Retourner None pour continuer normalement
    return None

def log_tool_usage(callback_context, tool_name, tool_result):
    """Log every tool call for monitoring."""
    print(f"[TOOL LOG] {tool_name}: {tool_result}")
    return None  # Ne pas modifier le résultat

root_agent = LlmAgent(
    name="safe_assistant",
    model="gemini-2.0-flash",
    instruction="You are a helpful assistant.",
    before_model_callback=safety_filter,
    after_tool_callback=log_tool_usage,
    description="A safety-filtered assistant with tool logging"
)

Le before_model_callback est le plus important pour la production. Il s'exécute avant chaque appel LLM, vous donnant la possibilité de bloquer les injections de prompt, de valider les entrées ou d'ajouter du contexte système. Si vous retournez un objet de réponse, ADK ignore entièrement le modèle. Retournez None pour laisser passer la requête. Pour plus de patterns, consultez les patterns approfondis pour les garde-fous de sécurité LLM.

Tester et évaluer vos agents ADK

ADK inclut un framework d'évaluation intégré avec deux types d'évaluateurs : ResponseEvaluator vérifie si la réponse finale de l'agent est correcte, et TrajectoryEvaluator vérifie que l'agent a suivi les bonnes étapes -- a appelé les bons outils dans le bon ordre. Rédigez des cas de test en fichiers JSON et exécutez-les avec pytest pour détecter les régressions avant le déploiement.

Pourquoi tester les agents ? Parce qu'ils sont non déterministes. La même entrée peut produire des sorties différentes, et un petit changement dans vos instructions peut casser l'appel d'outils de façon subtile. D'après notre expérience, les agents qui passent l'évaluation de trajectoire sont bien plus fiables en production que ceux testés uniquement sur la qualité de la sortie finale. Pour des stratégies d'évaluation plus larges, consultez notre guide sur les stratégies d'évaluation LLM.

Vos cas de test vont dans un fichier JSON :

[
  {
    "input": "What's the stock price of AAPL?",
    "expected_output": "198.50",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}}
    ]
  },
  {
    "input": "Compare AAPL and GOOGL prices",
    "expected_output": "AAPL.*198.*GOOGL.*175",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}},
      {"tool_name": "get_stock_price", "args": {"ticker": "GOOGL"}}
    ]
  }
]

Ensuite, exécutez les évaluations avec pytest. Le dépôt Python ADK contient la référence complète de l'API d'évaluation :

# test_agent.py
import pytest
from google.adk.evaluation import ResponseEvaluator, TrajectoryEvaluator

def test_stock_agent_response():
    evaluator = ResponseEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.8, f"Response pass rate too low: {results.pass_rate}"

def test_stock_agent_trajectory():
    evaluator = TrajectoryEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.9, f"Trajectory pass rate too low: {results.pass_rate}"

Lancez avec pytest test_agent.py -v. Définissez vos seuils en fonction de la criticité -- 80 % de précision de réponse peut convenir pour un agent de rédaction créative, mais vous voudrez 95 %+ pour tout ce qui gère des données financières.

Déployer votre agent Google ADK en production

Déployez votre agent ADK sur Google Cloud Run avec une seule commande : adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK emballe votre code, construit un conteneur et lance un endpoint serverless. Pour un hébergement géré, utilisez Vertex AI Agent Engine. Pour une infrastructure personnalisée, ADK supporte aussi la conteneurisation Docker.

Nous avons déployé des agents ADK sur Cloud Run pour des outils internes, et les temps de démarrage à froid sont étonnamment rapides -- moins de 3 secondes pour un agent de base. Pour les systèmes de production, pensez à associer votre déploiement à des outils de surveillance pour agents en production.

Déployer sur Cloud Run (recommandé pour la plupart)

Cloud Run est la voie la plus simple. Une commande, et votre agent est en ligne avec un endpoint HTTPS :

adk deploy cloud_run \
  --project your-gcp-project-id \
  --region us-central1 \
  --service-name my-agent-service \
  --with_ui

Le flag --with_ui déploie l'interface ADK Web aux côtés de votre agent, vous offrant un chat navigateur pour les tests en production. En arrière-plan, ADK construit une image de conteneur, la pousse vers Google Artifact Registry et crée un service Cloud Run. Le flux de déploiement complet est documenté dans le guide de démarrage rapide Cloud Run pour ADK de Google.

Pour une infrastructure personnalisée, voici un Dockerfile minimal :

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["adk", "api_server", "--port", "8080", "my_agent"]

Alternative : Vertex AI Agent Engine

Pour les équipes en entreprise qui ont besoin d'une mise à l'échelle gérée, d'une surveillance et d'un versionnage, Vertex AI Agent Engine gère entièrement l'infrastructure. Vous échangez la flexibilité contre la commodité -- aucun conteneur à gérer, mise à l'échelle automatique, analytique intégrée.

Considérations sur les coûts

Des chiffres réels à connaître :

• Niveau gratuit de l'API Gemini : 15 requêtes par minute, 1 million de tokens/jour. Suffisant pour le développement et les démonstrations légères.
• Gemini 2.0 Flash (payant) : 0,10 $ par million de tokens en entrée, 0,40 $ par million de tokens en sortie. Assez économique pour la production.
• Niveau gratuit Cloud Run : 2 millions de requêtes/mois, 360 000 Go-secondes de calcul. Un agent de base gérant 1 000 requêtes/jour reste largement dans le niveau gratuit.
• Conseil d'optimisation : Utilisez gemini-2.0-flash (et non gemini-2.0-pro) pour les sous-agents qui font du routage simple ou du formatage. Réservez les modèles plus puissants aux agents effectuant des raisonnements complexes.

L'approche de Techsy pour le développement d'agents IA

Chez Techsy, nous avons construit des systèmes multi-agents pour des clients en utilisant ADK, LangGraph et CrewAI. Le choix du framework dépend de votre stack : si vous êtes déjà sur Google Cloud, ADK élimine beaucoup de friction d'intégration. Si vous avez besoin d'un support LLM multi-fournisseurs dès le départ, LangGraph offre plus de flexibilité.

Notre engagement type commence par du conseil en architecture -- cartographier votre cas d'usage sur les bons patterns d'agents -- suivi du développement de prototype et du déploiement Cloud Run. Nous avons constaté que les équipes économisent 2 à 3 semaines en définissant correctement l'architecture dès le départ plutôt que de refactoriser ensuite.

Vous construisez des agents IA pour votre équipe ? Obtenez une consultation gratuite -- nous vous aiderons à choisir le bon framework et la bonne stratégie de déploiement.

Erreurs courantes et dépannage

Ce sont les erreurs que nous rencontrons le plus souvent au démarrage avec ADK. Évitez-vous ce temps de débogage :

Conseil de débogage : adk web est votre meilleur allié ici. Il affiche la trace complète de la conversation -- chaque appel au modèle, invocation d'outil et délégation d'agent -- en temps réel. Quand quelque chose se passe mal dans un système multi-agents, l'interface Web vous montre exactement où la chaîne s'est cassée.

FAQ

Qu'est-ce que Google ADK ?

Le Google Agent Development Kit (ADK) est un framework Python open source pour créer, évaluer et déployer des agents IA. Il est optimisé pour les modèles Google Gemini mais supporte plus de 100 LLM via l'intégration LiteLLM. Le point fort d'ADK est l'orchestration multi-agents native avec des outils intégrés, une interface de développement et un déploiement Cloud Run en une seule commande.

Google ADK est-il gratuit ?

Oui. ADK lui-même est open source sous licence Apache 2.0. Vous avez besoin d'une clé API Gemini, qui dispose d'un niveau gratuit offrant 15 requêtes par minute et 1 million de tokens par jour. Les coûts de déploiement dans le cloud dépendent de votre choix d'hébergement -- le niveau gratuit de Cloud Run couvre 2 millions de requêtes par mois.

Quelle est la différence entre Google ADK et LangChain ?

ADK est le framework opiniâtre de Google optimisé pour Gemini avec une orchestration multi-agents native et des outils de déploiement intégrés. LangChain est agnostique au modèle avec des intégrations tierces plus larges mais une complexité nettement plus élevée. ADK convient mieux aux équipes Gemini-first qui veulent un déploiement rapide ; LangChain convient aux configurations multi-fournisseurs nécessitant un maximum de flexibilité.

Google ADK supporte-t-il les systèmes multi-agents ?

Oui, et c'est la fonctionnalité phare d'ADK. Vous créez un agent racine qui délègue à des sous-agents spécialisés en fonction des demandes des utilisateurs. ADK propose aussi SequentialAgent, ParallelAgent et LoopAgent pour l'orchestration de workflow déterministe. Le pattern agent-comme-outil permet aux agents d'appeler d'autres agents comme des fonctions appelables.

Comment déployer un agent Google ADK ?

Lancez adk deploy cloud_run --project YOUR_PROJECT --region us-central1 pour un déploiement serverless sur Google Cloud Run. Ajoutez --with_ui pour inclure l'interface de chat navigateur. Vous pouvez aussi déployer sur Vertex AI Agent Engine pour un hébergement géré, ou construire un conteneur Docker pour une infrastructure personnalisée.

Google ADK peut-il utiliser des modèles autres que Gemini ?

Oui. ADK supporte plus de 100 modèles via l'intégration LiteLLM, dont Anthropic Claude, OpenAI GPT-4, Meta Llama et Mistral. Définissez le paramètre model sur la chaîne de modèle LiteLLM -- par exemple, litellm/anthropic/claude-3-sonnet ou litellm/openai/gpt-4o. Les modèles Gemini fonctionnent nativement sans le préfixe LiteLLM.

Qu'est-ce que l'interface ADK Web ?

Une interface de débogage navigateur lancée avec adk web votre_dossier_agent. Elle affiche les traces de conversation en temps réel, les appels d'outils, les chaînes de délégation d'agents et les changements d'état au fur et à mesure qu'ils se produisent. L'interface Web est indispensable pour déboguer les systèmes multi-agents car elle montre exactement quel sous-agent a traité chaque requête.

Google ADK supporte-t-il MCP (Model Context Protocol) ?

Oui. ADK dispose d'un support natif du Model Context Protocol, permettant aux agents de se connecter à n'importe quel serveur d'outils compatible MCP pour des outils et des sources de données externes. Cela rend les agents ADK interopérables avec l'écosystème MCP en pleine croissance. Pour le contexte sur le protocole, consultez notre guide MCP.

Comment tester les agents ADK ?

ADK intègre des évaluateurs : ResponseEvaluator pour vérifier la qualité de la sortie par rapport aux réponses attendues, et TrajectoryEvaluator pour vérifier que l'agent a appelé les bons outils dans le bon ordre. Rédigez des cas de test en fichiers JSON définissant les entrées, les sorties attendues et les séquences d'appels d'outils attendues, puis exécutez-les avec pytest.

Quelle version de Python Google ADK requiert-il ?

ADK requiert Python 3.9 ou supérieur. Python 3.10+ est recommandé pour la prise en charge complète des annotations de type, ce qui compte car ADK utilise les annotations de type pour générer les schémas d'outils. Python 3.11 ou 3.12 offrent également des améliorations de performances significatives pour les charges de travail d'agents. Installez avec pip install google-adk.