Premiers pas avec les workflows agentiques

Cette page explique comment configurer votre projet Android, configurer la bibliothèque genai-agent et créer votre premier agent sur l'appareil.

Prérequis

Avant de créer des workflows agentiques avec Gemini Nano, assurez-vous que votre environnement répond aux exigences suivantes :

Configurer votre projet

Ajoutez la dépendance genai-agent au fichier build.gradle.kts de votre module :

dependencies {
    // Gemini Nano agentic workflows
    implementation("com.google.mlkit:genai-agent:1.0.0-alpha1")

    // Optional: Only required when defining tools using Android AppFunctions
    implementation("androidx.appfunctions:appfunctions:1.0.0-alpha13")
    ksp("androidx.appfunctions:appfunctions-compiler:1.0.0-alpha13")
}

Créer votre premier agent

Un agent comporte deux composants principaux :

  • Définition de l'agent : instructions et garde-fous configurant le comportement de l'agent.
  • Exécuteur d'agent : moteur d'exécution qui communique avec AICore et gère les conversations.

1. Configurer l'agent et l'exécuteur

L'exemple de code suivant montre comment définir votre agent avec des instructions système et initialiser la classe AgentRunner :

import com.google.mlkit.genai.agent.Agent
import com.google.mlkit.genai.agent.AgentRunner

// 1. Build the agent configuration
val agent = Agent.builder()
    .setName("Assistant")
    .setInstructions("You are a helpful on-device assistant.")
    .build()

// 2. Initialize the runner
val runner = AgentRunner(agent)

2. Exécuter une conversation

Les conversations multitours conservent l'historique des dialogues d'un tour à l'autre à l'aide d'une instance AgentSession. Encapsulez le texte de votre prompt dans un objet Content et collectez la réponse diffusée en streaming :

import android.util.Log
import androidx.lifecycle.lifecycleScope
import com.google.mlkit.genai.agent.textTokens
import com.google.mlkit.genai.prompt.Content
import kotlinx.coroutines.launch

// Create or retrieve a conversation session
val session = runner.getOrCreateSession("chat_session")

val prompt = Content.builder()
    .text("Hello! Can you help me organize my day?")
    .build()

// Collect streamed tokens in a coroutine
lifecycleScope.launch {
    session.runAsync(prompt)
        .textTokens()
        .collect { token ->
            Log.d("Agent", token)
        }
}

Pour les requêtes ponctuelles pour lesquelles vous n'avez pas besoin de conserver l'historique des conversations, vous pouvez appeler directement la méthode runner.runSingleTurnAsync(prompt) :

lifecycleScope.launch {
    runner.runSingleTurnAsync(prompt)
        .textTokens()
        .collect { token ->
            Log.d("Agent", token)
        }
}

3. Effectuer un nettoyage des ressources

La classe AgentRunner implémente l'interface AutoCloseable. Lorsque votre composant ViewModel ou Activity est détruit, fermez l'exécuteur pour libérer les sessions actives et annuler les coroutines en arrière-plan :

runner.close()

Étapes suivantes

  • Ajouter des capacités à l'aide d'outils : donnez à votre agent la possibilité d'effectuer des actions ou d'interroger les données de l'application à l'aide d'AppFunctions Android. Consultez Définir des outils.
  • Conserver les sessions lors de la rotation : découvrez comment conserver l'instance AgentSession dans une classe ViewModel lors des modifications de configuration dans Gérer les sessions et le cycle de vie.
  • Se connecter à Compose : diffusez des événements et affichez des bulles de chat interactives dans Diffuser des événements et intégrer l'UI.