ADK Studio

Environnement de développement visuel pour la création d'agents d'IA par glisser-déposer.

Aperçu

ADK Studio fournit une interface low-code pour la conception, le test et le déploiement d'agents d'IA construits avec adk-rust. Créez visuellement des workflows multi-agents complexes, puis compilez-les en code Rust de production.

Installation

# Installer depuis crates.io (binaire autonome)
cargo install adk-studio

# Ou compiler à partir des sources
cargo build --release -p adk-studio

Démarrage rapide

# Démarrer le serveur studio
adk-studio

# Ouvrir dans le navigateur
open http://localhost:3000

Options CLI

# Lier à toutes les interfaces pour un accès à distance
adk-studio --host 0.0.0.0 --port 8080

# Répertoire de projets personnalisé
adk-studio --dir ./my-projects

---

Tutoriel pas à pas

Suivez ce guide pour créer votre premier Agent d'IA dans ADK Studio.

Étape 1 : Créer un nouveau projet

Cliquez sur le bouton + Nouveau projet dans le coin supérieur droit.

Saisissez un nom pour votre projet (par exemple, "Projet Démo") et cliquez sur Créer.

Étape 2 : Ajouter un Agent au Canevas

La barre latérale gauche contient la Palette d'Agents avec les types d'Agent disponibles :

• LlmAgent - Agent d'IA unique alimenté par un modèle de langage
• Sequential - Exécute les sous-Agents dans l'ordre
• Parallel - Exécute les sous-Agents concurremment
• Loop - Itère jusqu'à la condition de sortie
• Router - Route vers les sous-Agents en fonction de l'entrée

Cliquez sur LlmAgent pour l'ajouter au canevas.

Étape 3 : Configurer l'Agent

Lorsque vous sélectionnez un Agent, le Panneau de Propriétés apparaît sur le côté droit. Ici, vous pouvez configurer :

• Name - Identifiant de l'Agent
• Model - Fournisseur et modèle LLM (GeminiModel, OpenAIClient, AnthropicClient, etc.)
• Instructions - Prompt système pour l'Agent

Étape 4 : Ajouter des Outils à l'Agent

Faites défiler la barre latérale gauche pour trouver la Palette d'Outils :

• FunctionTool - Fonction Rust personnalisée avec éditeur de code
• MCP - Serveur Model Context Protocol
• Browser - 46 actions d'automatisation WebDriver
• Google Search - Recherche web basée sur le contexte
• Load Artifact - Charger des fichiers dans le contexte

Cliquez sur un Tool pour l'ajouter à votre Agent.

Étape 5 : Construire et Tester

Cliquez sur Build Project pour compiler votre Agent. Une fois compilé, utilisez le Panneau de Chat en bas pour tester votre Agent avec de vraies conversations.

Le chat prend en charge :

• Réponses en streaming SSE en direct
• Animations d'exécution d'Agent
• Panneau de trace d'événements pour le débogage

Étape 6 : Afficher le Code Généré

Cliquez sur View Code pour voir le code Rust prêt pour la production généré à partir de votre conception visuelle.

Vous pouvez copier ce code ou utiliser Compile pour générer un projet Rust complet.

---

Fonctionnalités

Types d'Agent

Types d'Outils

Chat en Temps Réel

Testez les agents directement dans le studio :

• Réponses en streaming SSE en direct
• Animations d'exécution d'agent
• Panneau de trace d'événements pour le débogage
• Persistance de la mémoire de Session

Génération de Code

Convertissez les conceptions visuelles en code de production :

1. Voir le Code - Prévisualisez le code Rust généré avec coloration syntaxique
2. Compiler - Générez un projet Rust complet
3. Construire - Compilez en exécutable avec sortie en temps réel
4. Exécuter - Exécutez l'agent construit

Architecture

┌─────────────────────────────────────────────────────────────┐
│                     ADK Studio UI                           │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Palette   │  │   Canvas    │  │   Properties        │ │
│  │  - Agents   │  │  ReactFlow  │  │  - Name             │ │
│  │  - Tools    │  │  Workflow   │  │  - Model            │ │
│  │             │  │  Designer   │  │  - Instructions     │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ HTTP/SSE
┌─────────────────────────────────────────────────────────────┐
│                    ADK Studio Server                        │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   Routes    │  │   Codegen   │  │   Storage           │ │
│  │  /api/*     │  │  Rust code  │  │  Projects           │ │
│  │  /chat      │  │  generation │  │  File-based         │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ Build
┌─────────────────────────────────────────────────────────────┐
│                   Generated Rust Project                    │
│  ┌─────────────────────────────────────────────────────┐   │
│  │  Cargo.toml + src/main.rs                           │   │
│  │  Uses: adk-rust, adk-agent, adk-model, etc.        │   │
│  └─────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────┘

Points de terminaison d'API

Projets

Génération de code

Discussion

Variables d'environnement

Structure du code généré

my-project/
├── Cargo.toml
└── src/
    └── main.rs

Exemple de main.rs généré :

use adk_rust::prelude::*;
use adk_rust::Launcher;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    dotenvy::dotenv().ok();
    let api_key = std::env::var("GOOGLE_API_KEY")?;
    let model = GeminiModel::new(&api_key, "gemini-2.0-flash")?;

    let agent = LlmAgentBuilder::new("assistant")
        .description("Helpful AI assistant")
        .instruction("You are a helpful assistant.")
        .model(Arc::new(model))
        .build()?;

    Launcher::new(Arc::new(agent)).run().await?;
    Ok(())
}

Modèles

Studio inclut des modèles pré-construits :

• Assistant de base - Agent LLM simple
• Agent de recherche - Agent avec recherche Google
• Routeur de support - Routage multi-agent
• Assistant de code - Agent avec outils de code

Bonnes pratiques

---

Précédent: ← Mémoire | Suivant: Directives de développement →