Anleitung: Erste Schritte mit der Gemini API


In dieser Anleitung wird gezeigt, wie Sie mit dem Google AI Client SDK for Android direkt über Ihre Android-App auf die Gemini API zugreifen. Sie können dieses Client SDK verwenden, wenn Sie für den Zugriff auf Gemini-Modelle in Ihrer Android-App nicht direkt mit REST APIs oder serverseitigem Code (wie Python) arbeiten möchten.

In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:

Darüber hinaus enthält diese Anleitung Abschnitte zu erweiterten Anwendungsfällen (z. B. Tokens zählen) sowie Optionen zum Steuern der Generierung von Inhalten.

Zugriff auf Gemini auf dem Gerät prüfen

Mit dem in dieser Anleitung beschriebenen Client-SDK für Android können Sie auf die Gemini Pro-Modelle zugreifen, die auf den Google-Servern ausgeführt werden. Für Anwendungsfälle, die die Verarbeitung sensibler Daten, die Offlineverfügbarkeit oder die Kosteneinsparungen für häufig verwendete Nutzerflüsse umfassen, können Sie auf Gemini Nano zugreifen, das auf dem Gerät ausgeführt wird. Weitere Informationen finden Sie in der Anleitung für Android (auf dem Gerät).

Voraussetzungen

In dieser Anleitung wird davon ausgegangen, dass Sie mit der Entwicklung von Android-Apps mit Android Studio vertraut sind.

Achten Sie beim Durcharbeiten dieser Anleitung darauf, dass Ihre Entwicklungsumgebung und Android-App die folgenden Anforderungen erfüllen:

  • Android Studio (neueste Version)
  • Deine Android-App muss auf API-Level 21 oder höher ausgerichtet sein.

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Android-Projekt einrichten. Dazu müssen Sie Ihren API-Schlüssel einrichten, dem Android-Projekt die SDK-Abhängigkeiten hinzufügen und das Modell initialisieren.

API-Schlüssel einrichten

Sie benötigen einen API-Schlüssel, um die Gemini API zu verwenden. Erstellen Sie einen Schlüssel in Google AI Studio, falls noch nicht geschehen.

API-Schlüssel anfordern

API-Schlüssel sichern

Wir empfehlen dringend, einen API-Schlüssel nicht in Ihr Versionsverwaltungssystem einzuchecken. Speichern Sie ihn stattdessen in einer local.properties-Datei, die sich im Stammverzeichnis Ihres Projekts befindet, von der Versionsverwaltung ausgeschlossen ist, und verwenden Sie dann das Secrets Gradle-Plug-in für Android, um Ihren API-Schlüssel als Build-Konfigurationsvariable zu lesen.

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;

Diese Best Practice wird in allen Snippets in dieser Anleitung angewendet. Wenn Sie sich die Implementierung des Secrets Gradle-Plug-ins ansehen möchten, können Sie sich auch die Beispiel-App für dieses SDK ansehen oder die aktuelle Vorschau von Android Studio Iguana verwenden. Dort finden Sie die Vorlage für die Gemini API Starter, die für den Einstieg die Datei local.properties enthält.

SDK-Abhängigkeit zum Projekt hinzufügen

  1. Fügen Sie in der Gradle-Konfigurationsdatei des Moduls (auf App-Ebene) (z. B. <project>/<app-module>/build.gradle.kts) die Abhängigkeit für das Google AI SDK for Android hinzu:

    Kotlin

    dependencies {
      // ... other androidx dependencies
    
      // add the dependency for the Google AI client SDK for Android
      implementation("com.google.ai.client.generativeai:generativeai:0.6.0")
    }
    

    Java

    Für Java müssen Sie zwei weitere Bibliotheken hinzufügen.

    dependencies {
        // ... other androidx dependencies
    
        // add the dependency for the Google AI client SDK for Android
        implementation("com.google.ai.client.generativeai:generativeai:0.6.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. Synchronisiere dein Android-Projekt mit Gradle-Dateien.

Generatives Modell initialisieren

Bevor Sie API-Aufrufe ausführen können, müssen Sie das generative Modell initialisieren:

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

Für Java müssen Sie außerdem das GenerativeModelFutures-Objekt initialisieren.

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

Beachten Sie bei der Angabe eines Modells Folgendes:

  • Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B. gemini-pro-vision ist für die multimodale Eingabe vorgesehen). In diesem Leitfaden ist in den Anleitungen für jede Implementierung das empfohlene Modell für den jeweiligen Anwendungsfall aufgeführt.

Gängige Anwendungsfälle implementieren

Nachdem Ihr Projekt nun eingerichtet ist, können Sie die Verwendung der Gemini API zum Implementieren verschiedener Anwendungsfälle kennenlernen:

Text aus reiner Texteingabe generieren

Wenn die Eingabe nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro-Modell mit generateContent, um eine Textausgabe zu generieren:

Kotlin

Beachten Sie, dass generateContent() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Beachten Sie, dass generateContent() einen ListenableFuture zurückgibt. Wenn Sie mit dieser API nicht vertraut sind, lesen Sie die Android-Dokumentation zur Verwendung eines 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);

Text aus Text- und Bildeingabe generieren (multimodal)

Gemini bietet verschiedene Modelle für multimodale Eingaben (Gemini 1.5-Modelle und Gemini 1.0 Pro Vision), sodass Sie sowohl Text als auch Bilder eingeben können. Sieh dir die Anforderungen an Bilder für Prompts an.

Wenn die Prompt-Eingabe sowohl Text als auch Bilder enthält, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro Vision-Modell mit generateContent, um die Textausgabe zu generieren:

Kotlin

Beachten Sie, dass generateContent() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Beachten Sie, dass generateContent() einen ListenableFuture zurückgibt. Wenn Sie mit dieser API nicht vertraut sind, lesen Sie die Android-Dokumentation zur Verwendung eines 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);

Multi-Turn Conversations (Chat)

Mit Gemini können Sie frei formulierte Unterhaltungen über mehrere Runden hinweg erstellen. Das SDK vereinfacht den Prozess, indem es den Status der Unterhaltung verwaltet. Im Gegensatz zu generateContent müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.

Verwenden Sie zum Erstellen einer Multi-Turn-Unterhaltung (z. B. Chat) ein Gemini 1.5-Modell oder das Gemini 1.0 Pro-Modell und initialisieren Sie den Chat durch Aufrufen von startChat(). Verwenden Sie dann sendMessage(), um eine neue Nutzernachricht zu senden, durch die auch die Nachricht und die Antwort dem Chatprotokoll hinzugefügt werden.

Es gibt zwei mögliche Optionen für role, die mit dem Inhalt einer Unterhaltung verknüpft sind:

  • user: die Rolle, die die Prompts bereitstellt. Dieser Wert ist der Standardwert für sendMessage-Aufrufe.

  • model: die Rolle, die die Antworten bereitstellt. Diese Rolle kann verwendet werden, wenn startChat() mit vorhandenem history aufgerufen wird.

Kotlin

Beachten Sie, dass generateContent() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Beachten Sie, dass generateContent() einen ListenableFuture zurückgibt. Wenn Sie mit dieser API nicht vertraut sind, lesen Sie die Android-Dokumentation zur Verwendung eines 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 userMessage = new Content.Builder()
    .setRole("user")
    .addText("How many paws are in my house?")
    .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);

Streaming für schnellere Interaktionen

Standardmäßig gibt das Modell eine Antwort zurück, nachdem der gesamte Generierungsprozess abgeschlossen ist. Sie können Interaktionen beschleunigen, indem Sie nicht auf das gesamte Ergebnis warten und stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Sie Streaming mit generateContentStream implementieren, um Text aus einer Text-und-Bild-Eingabe-Prompts zu generieren.

Kotlin

Beachten Sie, dass generateContentStream() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Die Java-Streamingmethoden in diesem SDK geben einen Publisher-Typ aus der Bibliothek Reactive Streams zurück.

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

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

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

    @Override
    public void onSubscribe(Subscription s) { }
});

Sie können einen ähnlichen Ansatz für Anwendungsfälle mit reiner Texteingabe und Chat verwenden:

Kotlin

Beachten Sie, dass generateContentStream() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Die Java-Streamingmethoden in diesem SDK geben einen Publisher-Typ aus der Bibliothek Reactive Streams zurück.

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

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

    // ... other methods omitted for brevity
});
// Use streaming with multi-turn conversations (like chat)
ChatFutures chat = model.startChat(history);

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

final String[] fullResponse = {""};

streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
    @Override
    public void onNext(GenerateContentResponse generateContentResponse) {
        String chunk = generateContentResponse.getText();
        fullResponse[0] += chunk;
    }

    @Override
    public void onComplete() {
        System.out.println(fullResponse[0]);
    }

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

Erweiterte Anwendungsfälle implementieren

Die im vorherigen Abschnitt dieser Anleitung beschriebenen häufigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die als komplexer gelten.

Funktionsaufrufe

Funktionsaufrufe erleichtern Ihnen die Ausgabe strukturierter Daten aus generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zurückzugeben. Mit anderen Worten: Funktionsaufrufe helfen Ihnen, generative Modelle mit externen Systemen zu verbinden, damit der generierte Inhalt die aktuellsten und genauesten Informationen enthält. Weitere Informationen finden Sie in der Anleitung zum Funktionsaufruf.

Anzahl der Tokens

Bei der Verwendung langer Aufforderungen kann es hilfreich sein, Tokens zu zählen, bevor Inhalte an das Modell gesendet werden. Die folgenden Beispiele zeigen, wie countTokens() für verschiedene Anwendungsfälle verwendet wird:

Kotlin

Beachten Sie, dass countTokens() eine Sperrfunktion ist und aus einem Koroutinenbereich aufgerufen werden muss. Wenn Sie mit Coroutinen nicht vertraut sind, lesen Sie den Artikel Kotlin-Coroutinen unter 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

Beachten Sie, dass countTokens() einen ListenableFuture zurückgibt. Wenn Sie mit dieser API nicht vertraut sind, lesen Sie die Android-Dokumentation zur Verwendung eines 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]));

Optionen zum Steuern der Inhaltsgenerierung

Sie können die Inhaltsgenerierung steuern, indem Sie Modellparameter konfigurieren und Sicherheitseinstellungen verwenden.

Modellparameter konfigurieren

Jede Aufforderung, die Sie an das Modell senden, enthält Parameterwerte, die steuern, wie das Modell eine Antwort generiert. Das Modell kann für verschiedene Parameterwerte unterschiedliche Ergebnisse generieren. Weitere Informationen zu Modellparametern

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

Sicherheitseinstellungen verwenden

In den Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden könnten. Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit werden standardmäßig durch Sicherheitseinstellungen in allen Dimensionen blockiert. Weitere Informationen zu Sicherheitseinstellungen

So legen Sie eine Sicherheitseinstellung fest:

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

Sie können auch mehrere Sicherheitseinstellungen festlegen:

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

Nächste Schritte

  • Beim Prompt-Design werden Aufforderungen erstellt, die die gewünschte Antwort aus Sprachmodellen auslösen. Gut strukturierte Eingabeaufforderungen sind wichtig, um genaue, hochwertige Antworten aus einem Sprachmodell zu gewährleisten. Best Practices für das Schreiben von Prompts

  • Gemini bietet verschiedene Modellvariationen, um den Anforderungen verschiedener Anwendungsfälle gerecht zu werden, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Dialogsprachaufgaben sowie Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen

  • Gemini bietet Optionen zum Anfordern von Erhöhungen der Ratenbegrenzung. Das Ratenlimit für Gemini Pro-Modelle beträgt 60 Anfragen pro Minute (RPM).

  • Mit dem in dieser Anleitung beschriebenen Client-SDK für Android können Sie auf die Gemini Pro-Modelle zugreifen, die auf den Google-Servern ausgeführt werden. Für Anwendungsfälle, die die Verarbeitung sensibler Daten, die Offlineverfügbarkeit oder die Kosteneinsparungen für häufig verwendete Nutzerflüsse umfassen, können Sie auf Gemini Nano zugreifen, das auf dem Gerät ausgeführt wird. Weitere Informationen finden Sie in der Anleitung für Android (auf dem Gerät).