Google AI Client SDK

Mit dem Google AI Client SDK können Sie die Gemini API aufrufen und die Gemini-Modelle direkt über Ihre Android-App verwenden.

Mit einer kostenlosen Stufe können Sie kostenlos experimentieren. Weitere Preisdetails finden Sie in der Preisübersicht.

Erste Schritte

Bevor Sie direkt über Ihre App mit der Gemini API interagieren können, müssen Sie einige Dinge tun. Dazu gehört, sich mit Prompts vertraut zu machen, einen API-Schlüssel zu generieren und Ihre App so einzurichten, dass sie das SDK verwendet.

Mit Prompts experimentieren

Erstellen Sie zuerst einen Prototyp Ihres Prompts in Google AI Studio.

Google AI Studio ist eine IDE für das Design und Prototyping von Prompts. Sie können Dateien hochladen, um Prompts mit Text und Bildern zu testen, und einen Prompt speichern, um ihn später noch einmal aufzurufen.

Der richtige Prompt für Ihren Anwendungsfall ist mehr Kunst als Wissenschaft, weshalb Tests entscheidend sind. Weitere Informationen zu Prompts finden Sie in der offiziellen Google AI-Dokumentation.

Weitere Informationen zu den erweiterten Funktionen von Google AI Studio finden Sie in der Google AI Studio-Kurzanleitung.

API-Schlüssel generieren

Wenn Sie mit dem Prompt zufrieden sind, klicken Sie auf API-Schlüssel abrufen, um Ihren Gemini API-Schlüssel zu generieren. Der Schlüssel wird mit Ihrer Anwendung gebündelt. Das ist für Tests und Prototypen in Ordnung, wird aber für den Produktionseinsatz nicht empfohlen.

Verwenden Sie außerdem das Secrets Gradle-Plug-in, um zu verhindern, dass Ihr API-Schlüssel in Ihr Quellcode-Repository committet wird.

Gradle-Abhängigkeit hinzufügen

Fügen Sie Ihrer App die Abhängigkeit für das Google AI Client SDK hinzu:

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

GenerativeModel erstellen

Erstellen Sie zuerst eine Instanz von GenerativeModel und geben Sie dazu Folgendes an:

• Modellname: gemini-1.5-flash, gemini-1.5-pro oder gemini-1.0-pro
• Den mit Google AI Studio generierten API-Schlüssel

Optional können Sie die Modellparameter definieren und Werte für Temperatur, Top-K, Top-P und maximale Ausgabetokens angeben.

Sie können die Sicherheitsfunktionen auch für die folgenden Themen definieren:

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

Google AI Client SDK in Ihrer App verwenden

Nachdem Sie einen API-Schlüssel haben und Ihre App so eingerichtet haben, dass sie das SDK verwendet, können Sie mit der Gemini API interagieren.

Text generieren

Wenn Sie eine Textantwort generieren möchten, rufen Sie generateContent() mit Ihrem Prompt auf.

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

generateContent() ist eine suspend-Funktion, die sich gut in vorhandenen Kotlin-Code einbinden lässt.

Text aus Bildern und anderen Medien generieren

Sie können auch Text aus einem Prompt generieren, der Text sowie Bilder oder andere Medien enthält. Wenn du generateContent() aufrufst, kannst du die Medien als Inline-Daten übergeben (wie im Beispiel unten gezeigt).

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

Unterhaltungen mit mehreren Antworten

Sie können auch Unterhaltungen über mehrere Themen unterstützen. Chat mit der Funktion startChat() initialisieren Optional können Sie einen Nachrichtenverlauf angeben. Rufen Sie dann die Funktion sendMessage() auf, um Chatnachrichten zu senden.

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

Antwort streamen

Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das vollständige Ergebnis der Modellgenerierung warten, sondern stattdessen Streaming zum Verarbeiten von Teilergebnissen verwenden. Verwenden Sie generateContentStream(), um eine Antwort zu streamen.

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 bietet zusätzliche Tools, die Ihnen den Einstieg erleichtern.

• Gemini API-Startvorlage: Mit dieser Vorlage können Sie einen API-Schlüssel direkt in Android Studio erstellen und ein Projekt generieren, das die erforderlichen Android-Abhängigkeiten für die Verwendung der Gemini APIs enthält.
• Generative AI-Beispiel: Mit diesem Beispiel können Sie das Google AI Client SDK für Android-Beispiel-App in Android Studio importieren.

Nächste Schritte

• Sehen Sie sich die Beispielanwendung für das Google AI Client SDK for Android auf GitHub an.
• Weitere Informationen zum Google AI Client SDK finden Sie in der offiziellen Google AI-Dokumentation.