In dieser Anleitung wird gezeigt, wie Sie mit dem Google AI Client SDK für Android direkt aus Ihrer Android-App auf die Gemini API zugreifen. Sie können dieses Client SDK verwenden, wenn Sie nicht direkt mit REST APIs oder serverseitigem Code (wie Python) für den Zugriff auf Gemini-Modelle in Ihrer Android-App arbeiten möchten.
In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:
- Projekt einschließlich API-Schlüssel einrichten
- Text aus reiner Texteingabe generieren
- Text aus Text- und Bildeingaben (multimodal) generieren
- Unterhaltungen mit mehreren Themen erstellen (Chat)
- Streaming für schnellere Interaktionen verwenden
Darüber hinaus enthält diese Anleitung Abschnitte zu erweiterten Anwendungsfällen (z. B. zum Zählen von Tokens) sowie Optionen zum Steuern der Inhaltsgenerierung.
Gemini auf dem Gerät verwenden
Mit dem in dieser Anleitung beschriebenen Client SDK für Android kannst du 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 Kosteneinsparungen bei häufig verwendeten Nutzerflüssen umfassen, kann es sinnvoll sein, auf Gemini Nano zuzugreifen, das auf dem Gerät ausgeführt wird. Weitere Informationen findest du in der Android-Anleitung auf dem Gerät.
Voraussetzungen
In dieser Anleitung wird davon ausgegangen, dass Sie mit der Verwendung von Android Studio zum Entwickeln von Android-Apps vertraut sind.
Damit Sie diese Anleitung abschließen können, müssen Ihre Entwicklungsumgebung und Ihre Android-App die folgenden Anforderungen erfüllen:
- Android Studio (neueste Version)
- Ihre 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 gehört auch das Einrichten des API-Schlüssels, das Hinzufügen der SDK-Abhängigkeiten zu Ihrem Android-Projekt und das Initialisieren des Modells.
API-Schlüssel einrichten
Zur Verwendung der Gemini API benötigen Sie einen API-Schlüssel. Falls noch nicht geschehen, erstellen Sie einen Schlüssel in Google AI Studio.
API-Schlüssel sichern
Es wird dringend empfohlen, keinen API-Schlüssel in das Versionsverwaltungssystem einzuchecken. Speichern Sie sie stattdessen in einer local.properties
-Datei, die sich im Stammverzeichnis Ihres Projekts befindet, aber von der Versionsverwaltung ausgeschlossen ist. Verwenden Sie dann das Secrets Gradle-Plug-in für Android, um den 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 bei allen Snippets in dieser Anleitung angewendet. Informationen zur Implementierung des Secrets Gradle-Plug-ins finden Sie in der Beispiel-App für dieses SDK. Alternativ können Sie auch die neueste Vorabversion von Android Studio Iguana mit der Vorlage Gemini API Starter mit der Datei local.properties
verwenden.
SDK-Abhängigkeit zum Projekt hinzufügen
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.9.0") }
Java
Für Java müssen zwei zusätzliche Bibliotheken hinzugefügt werden.
dependencies { // ... other androidx dependencies // add the dependency for the Google AI client SDK for Android implementation("com.google.ai.client.generativeai:generativeai:0.9.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") }
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
Bei Java müssen Sie auch 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 beim Angeben eines Modells Folgendes:
Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B.
gemini-1.5-flash
für eine multimodale Eingabe). In diesem Leitfaden wird in den Anleitungen für jede Implementierung das empfohlene Modell für jeden Anwendungsfall aufgeführt.
Gängige Anwendungsfälle implementieren
Nachdem Ihr Projekt nun eingerichtet ist, können Sie ausprobieren, wie Sie mit der Gemini API verschiedene Anwendungsfälle implementieren:
- Text aus reiner Texteingabe generieren
- Text aus Text- und Bildeingaben (multimodal) generieren
- Unterhaltungen mit mehreren Themen erstellen (Chat)
- Streaming für schnellere Interaktionen verwenden
Text aus reiner Texteingabe generieren
Wenn der Prompt nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro-Modell mit generateContent
, um die Textausgabe zu generieren:
Kotlin
Beachten Sie, dass generateContent()
eine Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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
generateContent()
gibt ListenableFuture
zurück. Wenn du mit dieser API nicht vertraut bist, lies die Android-Dokumentation unter ListenableFuture
verwenden.
// 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, die multimodale Eingaben verarbeiten können (Gemini 1.5-Modelle), sodass Sie sowohl Text als auch Bilder eingeben können. Lesen Sie unbedingt die Bildanforderungen für Prompts.
Wenn die Prompt-Eingabe sowohl Text als auch Bilder enthält, verwenden Sie ein Gemini 1.5-Modell mit generateContent
, um die Textausgabe zu generieren:
Kotlin
Beachten Sie, dass generateContent()
eine Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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
generateContent()
gibt ListenableFuture
zurück. Wenn du mit dieser API nicht vertraut bist, lies die Android-Dokumentation unter ListenableFuture
verwenden.
// 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 erstellen (Chat)
Mit Gemini kannst du Unterhaltungen im freien Format über mehrere Runden hinweg führen. Das SDK vereinfacht den Vorgang, da es den Status der Unterhaltung verwaltet. Im Gegensatz zu generateContent
müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.
Wenn Sie eine mehrsprachige Unterhaltung (z. B. Chat) erstellen möchten, verwenden Sie ein Gemini 1.5-Modell oder Gemini 1.0 Pro und initialisieren Sie den Chat, indem Sie startChat()
aufrufen.
Verwenden Sie dann sendMessage()
, um eine neue Nutzernachricht zu senden. Dadurch werden auch die Nachricht und die Antwort an das Chatprotokoll angehängt.
Es gibt zwei mögliche Optionen für role
, die dem Inhalt einer Unterhaltung zugeordnet sind:
user
: Die Rolle, die die Aufforderungen bereitstellt. Dies ist der Standardwert fürsendMessage
-Aufrufe.model
: Die Rolle, die die Antworten bereitstellt. Diese Rolle kann beim Aufrufen vonstartChat()
mit vorhandenemhistory
verwendet werden.
Kotlin
Beachten Sie, dass generateContent()
eine Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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
generateContent()
gibt ListenableFuture
zurück. Wenn du mit dieser API nicht vertraut bist, lies die Android-Dokumentation unter ListenableFuture
verwenden.
// 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);
Streaming für schnellere Interaktionen nutzen
Standardmäßig gibt das Modell nach Abschluss des gesamten Generierungsprozesses eine Antwort zurück. Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das gesamte Ergebnis warten, sondern stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.
Das folgende Beispiel zeigt, wie Streaming mit generateContentStream
implementiert wird, um Text über einen Text- und Bild-Eingabe-Prompt zu generieren.
Kotlin
Beachten Sie, dass generateContentStream()
eine Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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);
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);
}
});
Sie können einen ähnlichen Ansatz für reine Texteingabe und Chat-Anwendungsfälle verwenden:
Kotlin
Beachten Sie, dass generateContentStream()
eine Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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);
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
});
Erweiterte Anwendungsfälle implementieren
Die im vorherigen Abschnitt dieses Tutorials beschriebenen gängigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die möglicherweise als komplexer gelten.
Funktionsaufrufe
Funktionsaufrufe erleichtern es Ihnen, Ausgaben strukturierter Daten aus generativen Modellen zu erhalten. 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 die generierten Inhalte aktuelle und genaue Informationen enthalten. Weitere Informationen finden Sie in der Anleitung zu Funktionsaufrufen.
Anzahl der Tokens
Bei langen Prompts 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 Beendigungsfunktion ist und aus einem Coroutine-Bereich aufgerufen werden muss. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie den Artikel Kotlin-Koroutinen für 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
countTokens()
gibt ListenableFuture
zurück. Wenn du mit dieser API nicht vertraut bist, lies die Android-Dokumentation unter ListenableFuture
verwenden.
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 Inhaltserstellung
Sie können das Generieren von Inhalten 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
Mit Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden können. Standardmäßig blockieren Sicherheitseinstellungen Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit, die als unsicher eingestuft werden, in allen Dimensionen. Weitere Informationen zu den 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 Modellvarianten für verschiedene Anwendungsfälle, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Sprachaufgaben für Chats und Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen
Mit dem in dieser Anleitung beschriebenen Client SDK für Android kannst du 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 Kosteneinsparungen bei häufig verwendeten Nutzerflüssen umfassen, kann es sinnvoll sein, auf Gemini Nano zuzugreifen, das auf dem Gerät ausgeführt wird. Weitere Informationen findest du in der Android-Anleitung auf dem Gerät.