Pakiet SDK klienta Google AI

Pakiet SDK klienta Google AI umożliwia wywoływanie interfejsu Gemini API i używanie rodziny modeli Gemini bezpośrednio z aplikacji na Androida.

Poziom bezpłatny umożliwia eksperymentowanie bezpłatnie. Więcej informacji o cenach znajdziesz w cenniku.

Pierwsze kroki

Zanim zaczniesz korzystać z interfejsu Gemini API bezpośrednio z aplikacji, musisz wykonać kilka czynności, w tym zapoznać się z wyświetlaniem promptów, wygenerować klucz interfejsu API i skonfigurować aplikację do korzystania z pakietu SDK.

Eksperymentowanie z promptami

Zacznij od stworzenia prototypu prompta w Google AI Studio.

Google AI Studio to środowisko IDE do projektowania promptów i tworzenia prototypów. Umożliwia przesyłanie plików z tekstem i obrazami do testowania promptów oraz zapisywanie promptów, aby wrócić do nich później.

Stworzenie odpowiedniego promptu do danego zastosowania to bardziej sztuka niż nauka, dlatego eksperymentowanie jest kluczowe. Więcej informacji o promptach znajdziesz w oficjalnej dokumentacji Google AI.

Więcej informacji o zaawansowanych funkcjach Google AI Studio znajdziesz w przewodniku wdrożeniowym Google AI Studio.

Generowanie klucza interfejsu API

Gdy wszystko będzie gotowe, kliknij Uzyskaj klucz API, aby wygenerować klucz interfejsu Gemini API. Klucz będzie dołączony do aplikacji, co jest w porządku w przypadku eksperymentowania i tworzenia prototypów, ale nie jest zalecane w przypadku zastosowań produkcyjnych.

Aby zapobiec zatwierdzenie klucza API w repozytorium kodu źródłowego, użyj wtyczki Gradle do obsługi obiektów tajnych.

Dodawanie zależności Gradle

Dodaj do aplikacji zależność pakietu SDK klienta Google AI:

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

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")
}

Tworzenie GenerativeModel

Zacznij od utworzenia instancji GenerativeModel, podając te informacje:

• Nazwa modelu: gemini-1.5-flash, gemini-1.5-pro lub gemini-1.0-pro.
• Klucz API wygenerowany w Google AI Studio.

Opcjonalnie możesz zdefiniować parametry modelu i podać wartości dla temperatury, topK, topP i maksimum tokenów wyjściowych.

Możesz też zdefiniować funkcje bezpieczeństwa dotyczące tych tematów:

• HARASSMENT
• HATE_SPEECH
• SEXUALLY_EXPLICIT
• DANGEROUS_CONTENT

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),
  )
)

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
);

Korzystanie z pakietu SDK klienta Google AI w aplikacji

Teraz, gdy masz klucz interfejsu API i skonfigurowałaś/skonfigurowałeś aplikację do korzystania z pakietu SDK, możesz wchodzić w interakcje z interfejsem Gemini API.

Generowanie tekstu

Aby wygenerować odpowiedź tekstową, wywołaj funkcję generateContent() z promptem.

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

// 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);

Pamiętaj, że generateContent() to funkcja suspend, która dobrze integruje się z dotychczasowym kodem Kotlina.

generować tekst na podstawie obrazów i innych multimediów.

Możesz też wygenerować tekst na podstawie prompta zawierającego tekst oraz obrazy lub inne multimedia. Gdy wywołujesz funkcję generateContent(), możesz przekazywać dane multimedialne jako dane wbudowane (jak w przykładzie poniżej).

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

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);

Czat wieloetapowy

Możesz też obsługiwać rozmowy wieloetapowe. Inicjowanie czatu za pomocą funkcji startChat(). Opcjonalnie możesz podać historię wiadomości. Następnie wywołaj funkcję sendMessage(), aby wysłać wiadomości na czacie.

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?")
}

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);

Odpowiadaj na pytania stopniowo

Aby uzyskać szybsze interakcje, nie czekaj na pełny wynik wygenerowany przez model, ale zamiast tego użyj strumieniowego przetwarzania wyników częściowych. Użyj generateContentStream(), aby przesyłać strumieniowo odpowiedź.

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

// 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 zawiera dodatkowe narzędzia, które ułatwią Ci rozpoczęcie pracy.

• Szablon startowy Gemini API: ten szablon startowy pomaga utworzyć klucz API bezpośrednio w Android Studio i wygenerować projekt, który zawiera niezbędne zależności Androida do korzystania z interfejsów Gemini API.
• Przykład generatywnej AI: ten przykład umożliwia zaimportowanie pakietu SDK klienta Google AI do przykładowej aplikacji na Androida w Android Studio.

Dalsze kroki

• Sprawdź na GitHubie pakiet SDK klienta Google AI na Androida w przykładowej aplikacji.
• Więcej informacji o pakiecie SDK klienta Google AI znajdziesz w oficjalnej dokumentacji Google AI.