Tutorial: inizia a utilizzare l'API Gemini


Questo tutorial mostra come accedere all'API Gemini direttamente dalla tua app per Android utilizzando l'SDK client dell'IA di Google per Android. Puoi utilizzare questo SDK client se non vuoi lavorare direttamente con le API REST o con il codice lato server (come Python) per accedere ai modelli Gemini nella tua app per Android.

In questo tutorial imparerai a:

Inoltre, questo tutorial contiene sezioni sui casi d'uso avanzati (come il conteggio dei token) e sulle opzioni per controllare la generazione di contenuti.

Valuta la possibilità di accedere a Gemini on-device

L'SDK client per Android descritto in questo tutorial ti consente di accedere ai modelli Gemini Pro che vengono eseguiti sui server di Google. Per i casi d'uso che prevedono l'elaborazione di dati sensibili, la disponibilità offline o il risparmio sui costi per i flussi utente utilizzati di frequente, potrebbe essere utile accedere a Gemini Nano, che viene eseguito sul dispositivo. Per ulteriori dettagli, consulta il tutorial per Android (sul dispositivo).

Prerequisiti

Questo tutorial presuppone che tu abbia familiarità con l'utilizzo di Android Studio per sviluppare app per Android.

Per completare questo tutorial, assicurati che il tuo ambiente di sviluppo e la tua app Android soddisfino i seguenti requisiti:

  • Android Studio (versione più recente)
  • La tua app per Android deve avere il livello API target 21 o versioni successive.

Configura il progetto

Prima di chiamare l'API Gemini, devi configurare il progetto Android, che include la configurazione della chiave API, l'aggiunta delle dipendenze dell'SDK al progetto Android e l'inizializzazione del modello.

Configura la chiave API

Per utilizzare l'API Gemini, hai bisogno di una chiave API. Se non ne hai già una, crea una chiave in Google AI Studio.

Ottenere una chiave API

Proteggi la chiave API

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Dovresti invece archiviarla in un file local.properties (che si trova nella directory root del progetto, ma escluso dal controllo della versione), quindi utilizzare il plug-in Secrets Gradle per Android per leggere la chiave API come variabile di configurazione della build.

Kotlin 

// Access your API key as a Build Configuration variable
val apiKey = BuildConfig.apiKey

Java 

// Access your API key as a Build Configuration variable
String apiKey = BuildConfig.apiKey;

Tutti gli snippet di questo tutorial utilizzano questa best practice. Inoltre, se vuoi vedere l'implementazione del plug-in Secrets Gradle, puoi esaminare l'app di esempio per questo SDK o utilizzare l'ultima anteprima di Android Studio Iguana che ha un modello di avvio dell'API Gemini (che include il file local.properties per iniziare).

Aggiungi la dipendenza SDK al progetto

  1. Nel file di configurazione Gradle del modulo (a livello di app) (ad esempio <project>/<app-module>/build.gradle.kts), aggiungi la dipendenza per l'SDK Google AI per Android:

    Kotlin 

    dependencies {
  // ... other androidx dependencies

  // add the dependency for the Google AI client SDK for Android
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

    Java

    Per Java, devi aggiungere altre due librerie.

    dependencies {
    // ... other androidx dependencies

    // add the dependency for the Google AI client SDK for Android
    implementation("com.google.ai.client.generativeai:generativeai:0.7.0")

    // Required for one-shot operations (to use `ListenableFuture` from Guava Android)
    implementation("com.google.guava:guava:31.0.1-android")

    // Required for streaming operations (to use `Publisher` from Reactive Streams)
    implementation("org.reactivestreams:reactive-streams:1.0.4")
}

  2. Sincronizza il tuo progetto Android con i file Gradle.

Inizializzare il modello generativo

Prima di poter effettuare chiamate API, devi inizializzare il modello generativo:

Kotlin 

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with most use cases
    modelName = "gemini-1.5-flash",
    // Access your API key as a Build Configuration variable (see "Set up your API key" above)
    apiKey = BuildConfig.apiKey
)

Java

Per Java, devi anche inizializzare l'oggetto GenerativeModelFutures.

// Use a model that's applicable for your use case
// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
    /* apiKey */ BuildConfig.apiKey);

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Quando specifichi un modello, tieni presente quanto segue:

  • Utilizza un modello specifico per il tuo caso d'uso (ad esempio, gemini-1.5-flash è per l'input multimodale). All'interno di questa guida, le istruzioni per ogni implementazione elencano il modello consigliato per ogni caso d'uso.

Implementare casi d'uso comuni

Ora che il progetto è configurato, puoi esplorare l'utilizzo dell'API Gemini per implementare diversi casi d'uso:

Genera testo da input di solo testo

Quando l'input del prompt include solo testo, utilizza un modello Gemini 1.5 o Gemini 1.0 Pro con generateContent per generare un output di testo:

Kotlin

Tieni presente che generateContent() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
    modelName = "gemini-1.5-flash",
    // Access your API key as a Build Configuration variable (see "Set up your API key" above)
    apiKey = BuildConfig.apiKey
)

val prompt = "Write a story about a magic backpack."
val response = generativeModel.generateContent(prompt)
print(response.text)

Java

Tieni presente che generateContent() restituisce un ListenableFuture. Se non hai dimestichezza con questa API, consulta la documentazione di Android sull'utilizzo di un ListenableFuture.

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
    /* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content content = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Genera testo da input di testo e immagine (multimodale)

Gemini offre vari modelli in grado di gestire l'input multimodale (modelli Gemini 1.5). Assicurati di esaminare i requisiti relativi alle immagini per i prompt.

Quando l'input del prompt include sia testo che immagini, utilizza un modello Gemini 1.5 con generateContent per generare un output di testo:

Kotlin

Tieni presente che generateContent() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
    modelName = "gemini-1.5-flash",
    // Access your API key as a Build Configuration variable (see "Set up your API key" above)
    apiKey = BuildConfig.apiKey
)

val image1: Bitmap = // ...
val image2: Bitmap = // ...

val inputContent = content {
    image(image1)
    image(image2)
    text("What's different between these pictures?")
}

val response = generativeModel.generateContent(inputContent)
print(response.text)

Java

Tieni presente che generateContent() restituisce un ListenableFuture. Se non hai dimestichezza con questa API, consulta la documentazione di Android sull'utilizzo di un ListenableFuture.

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
    /* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Bitmap image1 = // ...
Bitmap image2 = // ...

Content content = new Content.Builder()
    .addText("What's different between these pictures?")
    .addImage(image1)
    .addImage(image2)
    .build();

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = model.generateContent(content);
Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Creare conversazioni in più passaggi (chat)

Con Gemini, puoi creare conversazioni in formato libero in più turni. L'SDK semplifica il processo gestendo lo stato della conversazione, quindi, a differenza di generateContent, non devi archiviare manualmente la cronologia delle conversazioni.

Per creare una conversazione in più passaggi (come la chat), utilizza un modello Gemini 1.5 o Gemini 1.0 Pro e inizializza la chat chiamando startChat(). Utilizza quindi sendMessage() per inviare un nuovo messaggio utente, che aggiungerà anche il messaggio e la risposta alla cronologia chat.

Esistono due possibili opzioni per role associate ai contenuti in una conversazione:

  • user: il ruolo che fornisce i prompt. Questo valore è il valore predefinito per le chiamate sendMessage.

  • model: il ruolo che fornisce le risposte. Questo ruolo può essere utilizzato durante la chiamata a startChat() con history esistente.

Kotlin

Tieni presente che generateContent() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
    modelName = "gemini-1.5-flash",
    // Access your API key as a Build Configuration variable (see "Set up your API key" above)
    apiKey = BuildConfig.apiKey
)

val chat = generativeModel.startChat(
    history = listOf(
        content(role = "user") { text("Hello, I have 2 dogs in my house.") },
        content(role = "model") { text("Great to meet you. What would you like to know?") }
    )
)

chat.sendMessage("How many paws are in my house?")

Java

Tieni presente che generateContent() restituisce un ListenableFuture. Se non hai dimestichezza con questa API, consulta la documentazione di Android sull'utilizzo di un ListenableFuture.

// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
    /* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

// (optional) Create previous chat history for context
Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

Content.Builder modelContentBuilder = new Content.Builder();
modelContentBuilder.setRole("model");
modelContentBuilder.addText("Great to meet you. What would you like to know?");
Content modelContent = userContentBuilder.build();

List<Content> history = Arrays.asList(userContent, modelContent);

// Initialize the chat
ChatFutures chat = model.startChat(history);

// Create a new user message
Content.Builder userMessageBuilder = new Content.Builder();
userMessageBuilder.setRole("user");
userMessageBuilder.addText("How many paws are in my house?");
Content userMessage = userMessageBuilder.build();

Executor executor = // ...

// Send the message
ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);

Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        String resultText = result.getText();
        System.out.println(resultText);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

Usa la modalità flusso per interazioni più rapide

Per impostazione predefinita, il modello restituisce una risposta dopo aver completato l'intero processo di generazione. Puoi ottenere interazioni più rapide non attendere l'intero risultato e utilizzare invece la modalità flusso per gestire i risultati parziali.

L'esempio seguente mostra come implementare i flussi di dati con generateContentStream per generare testo da un prompt di input di testo e immagine.

Kotlin

Tieni presente che generateContentStream() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
    modelName = "gemini-1.5-flash",
    // Access your API key as a Build Configuration variable (see "Set up your API key" above)
    apiKey = BuildConfig.apiKey
)

val image1: Bitmap = // ...
val image2: Bitmap = // ...

val inputContent = content {
    image(image1)
    image(image2)
    text("What's the difference between these pictures?")
}

var fullResponse = ""
generativeModel.generateContentStream(inputContent).collect { chunk ->
    print(chunk.text)
    fullResponse += chunk.text
}

Java

I metodi di flusso Java in questo SDK restituiscono un tipo Publisher dalla libreria Flussi reattivi.

// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
GenerativeModel gm = new GenerativeModel(/* modelName */ "gemini-1.5-flash",
// Access your API key as a Build Configuration variable (see "Set up your API key" above)
    /* apiKey */ BuildConfig.apiKey);
GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Bitmap image1 = // ...
Bitmap image2 = // ...

Content content = new Content.Builder()
    .addText("What's different between these pictures?")
    .addImage(image1)
    .addImage(image2)
    .build();

Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(content);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        outputContent.append(chunk);
    }

    @Override
    public void onComplete() {
        System.out.println(outputContent);
    }

    @Override
    public void onError(Throwable t) {
        t.printStackTrace();
    }

    @Override
    public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
    }
});

Puoi utilizzare un approccio simile per casi d'uso di input di solo testo e chat:

Kotlin

Tieni presente che generateContentStream() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

// Use streaming with text-only input
generativeModel.generateContentStream(inputContent).collect { chunk ->
    print(chunk.text)
}

// Use streaming with multi-turn conversations (like chat)
val chat = generativeModel.startChat()
chat.sendMessageStream(inputContent).collect { chunk ->
    print(chunk.text)
}

Java

I metodi di flusso Java in questo SDK restituiscono un tipo Publisher dalla libreria Flussi reattivi.

// Use streaming with text-only input
Publisher<GenerateContentResponse> streamingResponse =
    model.generateContentStream(inputContent);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        outputContent.append(chunk);
    }

    @Override
    public void onComplete() {
        System.out.println(outputContent);
    }

    @Override
    public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
    }

    // ... other methods omitted for brevity
});

// Use streaming with multi-turn conversations (like chat)
ChatFutures chat = model.startChat(history);

Publisher<GenerateContentResponse> streamingResponse =
    chat.sendMessageStream(inputContent);

StringBuilder outputContent = new StringBuilder();

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        outputContent.append(chunk);
    }

    @Override
    public void onComplete() {
        System.out.println(outputContent);
    }

    @Override
    public void onSubscribe(Subscription s) {
      s.request(Long.MAX_VALUE);
    }

    // ... other methods omitted for brevity
});

Implementare casi d'uso avanzati

I casi d'uso comuni descritti nella sezione precedente di questo tutorial ti aiutano ad acquisire dimestichezza con l'utilizzo dell'API Gemini. Questa sezione descrive alcuni casi d'uso che possono essere considerati più avanzati.

Chiamate di funzione

La chiamata di funzione semplifica l'ottenimento di output di dati strutturati da modelli generativi. Puoi quindi utilizzare questi output per chiamare altre API e restituire i dati di risposta pertinenti al modello. In altre parole, le chiamate di funzione consentono di collegare modelli generativi a sistemi esterni, in modo che i contenuti generati includano le informazioni più aggiornate e accurate. Scopri di più nel tutorial sulle chiamate di funzione.

Conta token

Quando utilizzi prompt lunghi, può essere utile contare i token prima di inviare contenuti al modello. I seguenti esempi mostrano come utilizzare countTokens() per vari casi d'uso:

Kotlin

Tieni presente che countTokens() è una funzione di sospensione e deve essere chiamata da un ambito Coroutine. Se non conosci Coroutines, leggi Kotlin Coroutines su Android.

// For text-only input
val (totalTokens) = generativeModel.countTokens("Write a story about a magic backpack.")

// For text-and-image input (multi-modal)
val multiModalContent = content {
    image(image1)
    image(image2)
    text("What's the difference between these pictures?")
}

val (totalTokens) = generativeModel.countTokens(multiModalContent)

// For multi-turn conversations (like chat)
val history = chat.history
val messageContent = content { text("This is the message I intend to send")}
val (totalTokens) = generativeModel.countTokens(*history.toTypedArray(), messageContent)

Java

Tieni presente che countTokens() restituisce un ListenableFuture. Se non hai dimestichezza con questa API, consulta la documentazione di Android sull'utilizzo di un ListenableFuture.

Content text = new Content.Builder()
    .addText("Write a story about a magic backpack.")
    .build();

Executor executor = // ...

// For text-only input
ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(text);

Futures.addCallback(countTokensResponse, new FutureCallback<CountTokensResponse>() {
    @Override
    public void onSuccess(CountTokensResponse result) {
        int totalTokens = result.getTotalTokens();
        System.out.println("TotalTokens = " + totalTokens);
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

// For text-and-image input
Bitmap image1 = // ...
Bitmap image2 = // ...

Content multiModalContent = new Content.Builder()
    .addImage(image1)
    .addImage(image2)
    .addText("What's different between these pictures?")
    .build();

ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(multiModalContent);

// For multi-turn conversations (like chat)
List<Content> history = chat.getChat().getHistory();

Content messageContent = new Content.Builder()
    .addText("This is the message I intend to send")
    .build();

Collections.addAll(history, messageContent);

ListenableFuture<CountTokensResponse> countTokensResponse = model.countTokens(history.toArray(new Content[0]));

Opzioni per controllare la generazione di contenuti

Puoi controllare la generazione di contenuti configurando i parametri del modello e utilizzando le impostazioni di sicurezza.

Configura i parametri del modello

Ogni prompt inviato al modello include valori parametro che controllano il modo in cui il modello genera una risposta. Il modello può generare risultati diversi per valori parametro diversi. Scopri di più sui parametri del modello.

Kotlin 

val config = generationConfig {
    temperature = 0.9f
    topK = 16
    topP = 0.1f
    maxOutputTokens = 200
    stopSequences = listOf("red")
}

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with most use cases
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey,
    generationConfig = config
)

Java 

GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.9f;
configBuilder.topK = 16;
configBuilder.topP = 0.1f;
configBuilder.maxOutputTokens = 200;
configBuilder.stopSequences = Arrays.asList("red");

GenerationConfig generationConfig = configBuilder.build();

// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash",
    BuildConfig.apiKey,
    generationConfig
);

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Utilizzare le impostazioni di sicurezza

Puoi utilizzare le impostazioni di sicurezza per modificare la probabilità di ricevere risposte che potrebbero essere considerate dannose. Per impostazione predefinita, le impostazioni di sicurezza bloccano i contenuti con probabilità media e/o alta di non essere sicuri in tutte le dimensioni. Scopri di più sulle impostazioni di sicurezza.

Per configurare un'impostazione di sicurezza:

Kotlin 

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with most use cases
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey,
    safetySettings = listOf(
        SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.ONLY_HIGH)
    )
)

Java 

SafetySetting harassmentSafety = new SafetySetting(HarmCategory.HARASSMENT,
    BlockThreshold.ONLY_HIGH);

// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash",
    BuildConfig.apiKey,
    null, // generation config is optional
    Collections.singletonList(harassmentSafety)
);

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Puoi anche configurare più di un'impostazione di sicurezza:

Kotlin 

val harassmentSafety = SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.ONLY_HIGH)

val hateSpeechSafety = SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE)

val generativeModel = GenerativeModel(
    // The Gemini 1.5 models are versatile and work with most use cases
    modelName = "gemini-1.5-flash",
    apiKey = BuildConfig.apiKey,
    safetySettings = listOf(harassmentSafety, hateSpeechSafety)
)

Java 

SafetySetting harassmentSafety = new SafetySetting(HarmCategory.HARASSMENT,
    BlockThreshold.ONLY_HIGH);

SafetySetting hateSpeechSafety = new SafetySetting(HarmCategory.HATE_SPEECH,
    BlockThreshold.MEDIUM_AND_ABOVE);

// The Gemini 1.5 models are versatile and work with most use cases
GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash",
    BuildConfig.apiKey,
    null, // generation config is optional
    Arrays.asList(harassmentSafety, hateSpeechSafety)
);

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Passaggi successivi

  • La progettazione dei prompt è il processo di creazione di prompt che suscitano la risposta desiderata dai modelli linguistici. Scrivere prompt ben strutturati è essenziale per garantire risposte accurate e di alta qualità da un modello linguistico. Scopri le best practice per la scrittura di prompt.

  • Gemini offre diverse varianti del modello per soddisfare le esigenze di diversi casi d'uso, come tipi di input e complessità, implementazioni di chat o altre attività basate su dialoghi di dialoghi e limiti di dimensioni. Scopri di più sui modelli Gemini disponibili.

  • L'SDK client per Android descritto in questo tutorial ti consente di accedere ai modelli Gemini Pro che vengono eseguiti sui server di Google. Per i casi d'uso che prevedono l'elaborazione di dati sensibili, la disponibilità offline o il risparmio sui costi per i flussi utente utilizzati di frequente, potrebbe essere utile accedere a Gemini Nano, che viene eseguito sul dispositivo. Per ulteriori dettagli, consulta il tutorial per Android (sul dispositivo).