SDK client Google AI

L'SDK client Google AI ti consente di chiamare l'API Gemini e di utilizzare la famiglia di modelli Gemini direttamente dalla tua app per Android.

Un livello senza costi ti consente di eseguire esperimenti senza costi. Per altri dettagli sui prezzi, consulta la guida ai prezzi.

Architettura di integrazione dell'IA di Google
Figura 1. Architettura di integrazione dell'IA di Google.

Per iniziare

Prima di interagire con l'API Gemini direttamente dalla tua app, devi svolgere alcune operazioni preliminari, ad esempio familiarizzare con i prompt, generare una chiave API e configurare la tua app per l'utilizzo dell'SDK.

Sperimenta con i prompt

Inizia creando un prototipo del prompt in Google AI Studio.

Google AI Studio è un IDE per la progettazione e la prototipazione dei prompt. Ti consente di caricare file per testare i prompt con testo e immagini e di salvare un prompt per rivisitarlo in un secondo momento.

Creare il prompt giusto per il tuo caso d'uso è più un'arte che una scienza, il che rende la sperimentazione fondamentale. Per scoprire di più sui prompt, consulta la documentazione ufficiale dell'AI di Google.

Google AI Studio
Figura 2. Google AI Studio

Per scoprire di più sulle funzionalità avanzate di Google AI Studio, consulta la guida rapida di Google AI Studio.

Genera la chiave API

Una volta soddisfatto del prompt, fai clic su Ottieni chiave API per generare la tua chiave API Gemini. La chiave verrà fornita in bundle con la tua applicazione, il che va bene per la sperimentazione e la prototipazione, ma non è consigliata per i casi di utilizzo in produzione.

Inoltre, per impedire che la chiave API venga committata nel repository del codice sorgente, utilizza il plug-in Gradle Secrets.

Aggiungi la dipendenza Gradle

Aggiungi la dipendenza per l'SDK client Google AI alla tua app:

Kotlin

dependencies {
  [...]
 implementation("com.google.ai.client.generativeai:generativeai:0.7.0")
}

Java

dependencies {
  [...]
  implementation("com.google.ai.client.generativeai:generativeai:0.7.0")

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

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

Crea un GenerativeModel

Inizia creando un'istanza di GenerativeModel fornendo quanto segue:

  • Il nome del modello: gemini-1.5-flash, gemini-1.5-pro o gemini-1.0-pro
  • La tua chiave API generata con Google AI Studio.

Se vuoi, puoi definire i parametri del modello e fornire valori per temperatura, topK, topP e token di output massimi.

Puoi anche definire le funzionalità di sicurezza per i seguenti argomenti:

  • HARASSMENT
  • HATE_SPEECH
  • SEXUALLY_EXPLICIT
  • DANGEROUS_CONTENT

Kotlin

val model = GenerativeModel(
  model = "gemini-1.5-flash-001",
  apiKey = BuildConfig.apikey,
  generationConfig = generationConfig {
    temperature = 0.15f
    topK = 32
    topP = 1f
    maxOutputTokens = 4096
  },
  safetySettings = listOf(
    SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE),
    SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE),
  )
)

Java

GenerationConfig.Builder configBuilder = new GenerationConfig.Builder();
configBuilder.temperature = 0.15f;
configBuilder.topK = 32;
configBuilder.topP = 1f;
configBuilder.maxOutputTokens = 4096;

ArrayList<SafetySetting> safetySettings = new ArrayList();
safetySettings.add(new SafetySetting(HarmCategory.HARASSMENT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.HATE_SPEECH, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.SEXUALLY_EXPLICIT, BlockThreshold.MEDIUM_AND_ABOVE));
safetySettings.add(new SafetySetting(HarmCategory.DANGEROUS_CONTENT, BlockThreshold.MEDIUM_AND_ABOVE));

GenerativeModel gm = new GenerativeModel(
    "gemini-1.5-flash-001",
    BuildConfig.apiKey,
    configBuilder.build(),
    safetySettings
);

Utilizzare l'SDK client di IA di Google nella tua app

Ora che hai una chiave API e hai configurato la tua app per utilizzare l'SDK, puoi interagire con l'API Gemini.

Genera testo

Per generare una risposta di testo, chiama generateContent() con il tuo prompt.

Kotlin

scope.launch {
  val response = model.generateContent("Write a story about a green robot.")
}

Java

// In Java, create a GenerativeModelFutures from the GenerativeModel.
// generateContent() returns a ListenableFuture.
// Learn more:
// https://developer.android.com/develop/background-work/background-tasks/asynchronous/listenablefuture

GenerativeModelFutures model = GenerativeModelFutures.from(gm);

Content content = new Content.Builder()
      .addText("Write a story about a green robot.")
      .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();
      }

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

Tieni presente che generateContent() è una funzione suspend, che si integra bene con il codice Kotlin esistente.

Genera testo da immagini e altri contenuti multimediali

Puoi anche generare testo da un prompt che include testo, immagini o altri contenuti multimediali. Quando chiami generateContent(), puoi passare i contenuti multimediali come dati in linea (come mostrato nell'esempio di seguito).

Kotlin

scope.launch {
  val response = model.generateContent(
    content {
      image(bitmap)
      text("What is the object in this picture?")
    }
  )
}

Java

Content content = new Content.Builder()
     .addImage(bitmap)
     .addText("What is the object in this picture?")
     .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();
      }

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

Chat multi-turno

Puoi anche supportare conversazioni a più turni. Inizializza una chat con la funzione startChat(). Se vuoi, puoi fornire una cronologia dei messaggi. Quindi, chiama la funzione sendMessage() per inviare messaggi di chat.

Kotlin

val chat = model.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?") }
    )
)

scope.launch {
   val response = chat.sendMessage("How many paws are in my house?")
}

Java

Content.Builder userContentBuilder = new Content.Builder();
userContentBuilder.setRole("user");
userContentBuilder.addText("Hello, I have 2 dogs in my house.");
Content userContent = userContentBuilder.build();

// (Optional) create message history
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);

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

Executor executor = // ...

ListenableFuture<GenerateContentResponse> response = chat.sendMessage(userMessage);

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

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

Visualizza la risposta in streaming

Puoi ottenere interazioni più rapide non aspettando l'intero risultato della generazione del modello, ma utilizzando lo streaming per gestire i risultati parziali. Utilizza generateContentStream() per trasmettere una risposta in streaming.

Kotlin

someScope.launch {
  var outputContent = ""
  
  generativeModel.generateContentStream(inputContent)
    .collect { response ->
      outputContent += response.text
    }
}

Java

// In Java, the method generateContentStream() returns a Publisher
// from the Reactive Streams library.
// https://www.reactive-streams.org/

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() {
        // ...
    }

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

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

Android Studio

Android Studio fornisce strumenti aggiuntivi per aiutarti a iniziare.

  • Modello di partenza dell'API Gemini: questo modello di partenza ti aiuta a creare una chiave API direttamente da Android Studio e genera un progetto che include le dipendenze Android necessarie per utilizzare le API Gemini.
  • Esempio di IA generativa: questo esempio ti consente di importare l'SDK client Google AI per l'app di esempio Android in Android Studio.

Passaggi successivi