Création d’agents IA bout en bout avec les compétences de développement ADK
Agents IA bout en bout avec des compétences en développement Google ADK : quelles sont ces compétences, lesquelles existent, et comment elles couvrent la construction, les tests, CI/CD et l’observabilité pour les agents.
Les notes suivantes reconstituent un parcours pratique autour du sujet « Construction d’agents IA bout en bout avec les compétences ADK Dev ». L’accent est mis sur les contrats, les vérifications et les placeholders de code à insérer, plutôt que sur une approche motivante.
Introduction
Lors de la phase d’introduction, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Considérez cette phase comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez les vérifications de succès et refusez toute exécution partielle silencieuse. Faites des points de contrôle après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel du LLM lorsque l’opérateur réessaie un nœud ultérieur.
Qu’est-ce que les compétences ADK Dev ?
Lorsque vous travaillez sur l’étape « What Are ADK Dev », notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe de la démonstration aux environnements partagés. Faites un point après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur réessaie un nœud ultérieur.
Compétences disponibles
Lors de la phase des compétences disponibles, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Créez un point de contrôle après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur réessaie un nœud ultérieur.
Compatibilité
Lors de la phase de compatibilité, notez d’abord les éléments essentiels du contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez en même temps le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Faites un point après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur tente à nouveau un nœud ultérieur.
Prérequis
Lors de la phase des Prérequis, notez d’abord les conditions du contrat : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Faites des points de contrôle après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel du LLM lorsque l’opérateur réessaie un nœud ultérieur. Lors de la phase des Prérequis, notez d’abord les conditions du contrat : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.
# Required tools
- Node.js (for npx)
- Python 3.10+
- uv package manager (pip install uv)
- Google Cloud SDK (gcloud)
- An active GCP project with billing enabled
gcloud config set project YOUR_PROJECT_ID
gcloud auth application-default login
Étape 1 : Installer ADK Dev Skills
L’étape d’installation d’ADK en tant que première étape fonctionne le mieux si elle est considérée comme une surface mesurable. Capturez un exemple réussi, un cas d’échec et des notes de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du graphique. Garantissez que l’état du graphique reste simple et typé. Les blocs imbriqués masquent l’identité du nœud qui a écrit tel champ et perturbent la reprise après interruption.
npx skills add google/adk-docs/skills -y -g
npx skills list
Étape 2 : Définir vos exigences
La étape 2 « Définir votre phase » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez en même temps le parcours optimal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Gardez l’état des graphes simple et typé : les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
I need to build a Retail Returns multiagent system using ADK.
Requirements:
- Check order status by order ID
- Process refunds for delivered orders
- Multi-agent architecture with routing
- Production deployment to Agent Engine
Étape 3 : Générer le squelette du projet
La phase Étape 3 : Générer le projet fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et une note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Maintenez l’état du graphe simple et typé. Les blocs imbriqués masquent le fait que tel nœud a écrit tel champ et perturbent la reprise après interruption. La phase Étape 3 : Générer le projet fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et une note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’une démonstration à des environnements partagés.
Use adk-scaffold to create this project with:
- Agent Engine deployment target
- GitHub Actions CI/CD
- No datastore needed (we'll use mock data)
retail-returns/
├── app/ # Our agent code
├── tests/ # Unit, integration, eval tests
├── .github/workflows/ # CI/CD pipelines
├── deployment/terraform/ # Infrastructure as code
├── notebooks/ # Jupyter notebooks
└── Makefile # Common development commands
Étape 4 : Mettre en œuvre la logique métier
Pour l’étape 4 « Mettre en œuvre le processus métier », définissez les entrées, le responsable de l’étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Imposez une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. Une connexion effectuée en temps de compilation ne garantit pas la complétude du processus métier.
Add tools for:
1. check_order_status(order_id: str) -> dict
2. process_refund(order_id: str) -> dict
Use mock data with 3 sample orders. Refunds only work for delivered orders.
# Mock database
ORDERS = {
"12345": {"status": "shipped", "total": 45.99, "items": ["T-shirt"], "refunded": False},
"67890": {"status": "delivered", "total": 120.50, "items": ["Shoes", "Socks"], "refunded": False},
}
async def check_order_status(order_id: str) -> dict:
"""Checks order status and details."""
if order_id in ORDERS:
return {"status": "success", "order": ORDERS[order_id]}
return {"status": "error", "message": f"Order {order_id} not found."}
async def process_refund(order_id: str) -> dict:
"""Processes refund with validation."""
if order_id not in ORDERS:
return {"status": "error", "message": f"Order {order_id} not found."}
order = ORDERS[order_id]
if order["status"] != "delivered":
return {"status": "error", "message": "Order must be delivered"}
if order["refunded"]:
return {"status": "error", "message": "Already refunded"}
order["refunded"] = True
return {"status": "success", "transaction_id": f"REF-{order_id}-123"}
from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.models import Gemini
def create_status_agent() -> Agent:
return Agent(
name="status_agent",
model=Gemini(model="gemini-3-flash-preview"),
instruction="Look up orders using check_order_status tool.",
tools=[check_order_status],
)
def create_refund_agent() -> Agent:
return Agent(
name="refund_agent",
model=Gemini(model="gemini-3-flash-preview"),
instruction="Verify order is delivered before processing refund.",
tools=[check_order_status, process_refund],
)
root_agent = Agent(
name="triage_agent",
model=Gemini(model="gemini-3-flash-preview"),
instruction="Route requests to status_agent or refund_agent.",
sub_agents=[create_status_agent(), create_refund_agent()],
)
app = App(name="retail_returns_app", root_agent=root_agent)
Étape 5 : Tester localement
Pour l’étape « Tester localement, étape 5 », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours idéal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Imposez une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. Une connexion en temps de compilation ne garantit pas la complétude du fonctionnement commercial.
Let's test this locally
cd retail-returns
make install
make playground
Étape 6 : Créer des évaluations
Pour l’étape 6 « Créer des évaluations », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Faites approuver par un humain les actions qui entraînent des dépenses ou modifient des données de production. Une connexion en temps de compilation ne garantit pas la complétude du processus métier. Pour l’étape 6 « Créer des évaluations », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la version démo à l’environnement partagé.
...
Create an evaluation to test invalid order handling
{
"eval_set_id": "invalid_orders",
"eval_cases": [
{
"eval_id": "invalid_status_check",
"conversation": [
{"user_content": {"parts": [{"text": "What's the status of order #99999?"}]}}
],
"expected_tool_calls": [
{"tool_name": "check_order_status", "args": {"order_id": "99999"}}
]
},
{
"eval_id": "invalid_refund",
"conversation": [
{"user_content": {"parts": [{"text": "I want a refund for order #88888"}]}}
]
}
]
}
{
"criteria": {
"tool_trajectory_avg_score": {
"threshold": 1.0,
"match_type": "IN_ORDER"
},
"final_response_match_v2": {
"threshold": 0.8,
"judgeModelOptions": {"judgeModel": "gemini-3-flash-preview"}
}
}
}
make eval
Tests passed: 2
Tests failed: 0
Étape 7 : Déploiement en production
Lors de l’exécution de l’étape 7 de déploiement, notez d’abord les éléments requis : les entrées nécessaires, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Créez des points de contrôle après les étapes coûteuses. Le mécanisme de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque un opérateur réessaie un nœud ultérieur.
Deploy this to Agent Engine
# Export dependencies
uv export --no-hashes > app/app_utils/.requirements.txt
# Deploy to Vertex AI
uv run -m app.app_utils.deploy \
--source-packages=./app \
--entrypoint-module=app.agent_engine_app \
--entrypoint-object=agent_engine \
--requirements-file=app/app_utils/.requirements.txt
import vertexai
client = vertexai.Client(project="YOUR_PROJECT", location="us-central1")
agent = client.agent_engines.get(name="ENGINE_ID")
async for event in agent.async_stream_query(
message="Where is order #12345?",
user_id="test"
):
print(event)
Étape 8 : Mise en place de CI/CD
Lors de l’étape 8 « Configuration », notez d’abord les éléments du contrat : les données requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Créez des points de contrôle après les étapes coûteuses. Le mécanisme de reprise ne doit pas facturer à nouveau la même appel du LLM lorsque l’opérateur tente à nouveau un nœud ultérieur.
Set up CI/CD with GitHub Actions
1. Vérifications PR (.github/workflows/pr_checks.yaml)
Lors du traitement de l’étape GitHub « 1 PR Checks », notez d’abord les conditions requises : les entrées nécessaires, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle garantit l’honnêteté des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité et non un processus embrouillé. Créez des points de contrôle après les étapes coûteuses. Le mécanisme de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur réessaie un nœud ultérieur. Lors du traitement de l’étape GitHub « 1 PR Checks », notez d’abord les conditions requises : les entrées nécessaires, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle garantit l’honnêteté des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
2. Déploiement en phase de test (.github/workflows/staging.yaml)
La phase GitHub de déploiement en phase de test fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple parfait de fonctionnement, un cas d’échec et des notes de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stocks de secrets et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du schéma. Maintenez un état du schéma plat et typé. Les blocs imbriqués masquent l’identité du nœud qui a écrit tel champ et empêchent la reprise après interruption.
3. Déploiement en production (.github/workflows/deploy-to-prod.yaml)
La phase github de déploiement en production fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript idéal, un cas d’échec et la note de rollback avant d’élargir le périmètre. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Gardez l’état des graphes plat et typé : les blobs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
uvx agent-starter-pack setup-cicd \
--staging-project YOUR_STAGING_PROJECT \
--prod-project YOUR_PROD_PROJECT \
--repository-name YOUR_REPO \
--repository-owner YOUR_GITHUB_USER \
--auto-approve
Étape 9 : Observabilité
La phase d’Observabilité de l’Étape 9 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et une note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Maintenez l’état des graphes simple et typé. Les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption. La phase d’Observabilité de l’Étape 9 fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et une note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
How's observability configured?
Intégré (Aucune configuration requise)
Pour l’étape « Intégré, aucune configuration requise », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Mettez en place une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas la complétude du processus métier.
Intégrations optionnelles
Pour l’étape des intégrations optionnelles, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Imposez une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas l’exhaustivité du fonctionnement commercial.
# Add to app/agent.py
from google.adk.plugins import BigQueryAgentAnalyticsPlugin
app = App(
root_agent=root_agent,
plugins=[BigQueryAgentAnalyticsPlugin(dataset="agent_analytics")]
)
Étape 10 : Écrire des tests pour la production
Pour l’étape 10 « Écrire des tests », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Faites approuver par un humain les actions qui entraînent des dépenses ou modifient des données de production. Une connexion en temps de compilation ne garantit pas la complétude du processus métier. Pour l’étape 10 « Écrire des tests », définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
Create integration tests that hit the deployed agent
import pytest
import requests
import subprocess
def get_access_token():
result = subprocess.run(
["gcloud", "auth", "print-access-token"],
capture_output=True, text=True
)
return result.stdout.strip()
@pytest.mark.integration
def test_valid_order_status():
"""Test order lookup on deployed agent."""
token = get_access_token()
response = requests.post(
f"https://us-central1-aiplatform.googleapis.com/v1/projects/{PROJECT_NUM}/locations/us-central1/reasoningEngines/{ENGINE_ID}:streamQuery",
headers={"Authorization": f"Bearer {token}"},
json={"input": {"message": "Where is order #12345?", "user_id": "test"}}
)
assert response.status_code == 200
text = "".join(event.get("text", "") for event in response.json())
assert "shipped" in text.lower()
assert "45.99" in text
pytest tests/integration/test_remote_agent.py
Au préalable et après
Lors de l’étape « Au préalable et après », notez d’abord les éléments requis : les entrées nécessaires, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Créez un point de contrôle après les étapes coûteuses. Le mécanisme de reprise ne doit pas facturer à nouveau la même appel du LLM lorsque l’opérateur réessaie un nœud ultérieur.
Sans compétences spécifiques
Lorsque vous travaillez sur l’étape « Sans compétences », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie du produit, et non d’améliorations ultérieures. Faites un point après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur réessaie un nœud ultérieur.
Avec compétences
Lors de la phase « With Skills », notez d’abord les conditions du contrat : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Faites des points de contrôle après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel d’LLM lorsque l’opérateur réessaie un nœud ultérieur. Lors de la phase « With Skills », notez d’abord les conditions du contrat : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de garantir l’honnêteté des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe de l’environnement de démonstration à des environnements partagés.
Bonnes pratiques et conseils
La phase des meilleures pratiques et conseils fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Recueillez un transcript exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du graphe. Maintenez un état du graphe plat et typé. Les blocs imbriqués masquent l’identité du nœud qui a écrit tel champ et perturbent la reprise après interruption.
1. Installer les compétences de manière globale
La phase « 1 Install Skills Globally » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez en même temps le parcours réussi et celui de récupération. Les tentatives répétées, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Gardez l’état des graphes simple et typé ; les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
npx skills add google/adk-docs/skills -y -g
2. Soyez précis dans vos demandes
La méthode « 2 Soyez spécifiques » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables plutôt que des scripts étendus. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus complexe. Fixez des limites de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démos ne se transforment en factures inattendues.
3. Utilisez les compétences appropriées pour chaque phase
4. Itérez avec des évaluations
5. Vérifiez le code généré
6. Utilisez un contrôle de version
git init
git add .
git commit -m "Initial scaffold from ADK Dev Skills"
Questions fréquentes
Faut-il d’abord apprendre ADK ?
Pouvons-nous modifier le code généré ?
Cela fonctionnera-t-il avec d’autres assistants IA ?
Que se passe-t-il si nous voulons déployer sur Cloud Run à la place ?
Pouvons-nous créer nos propres compétences ?
Comment mettons-nous à jour les compétences ?
npx skills add google/adk-docs/skills -y -g