Anleitung: Erste Schritte mit der Gemini API


In diesem Tutorial erfahren Sie, wie Sie direkt von Ihrem Android-App mit dem Google AI Client SDK für Android Sie können diese Client SDK verwenden, wenn Sie nicht direkt mit REST APIs oder serverseitigem Code arbeiten möchten wie Python, um auf Gemini-Modelle in Ihrer Android-App zuzugreifen.

In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:

Darüber hinaus enthält dieses Tutorial Abschnitte zu fortgeschrittenen Anwendungsfällen (z. B. Zählen von Tokens) sowie Optionen für Generieren von Inhalten.

Gemini auf dem Gerät verwenden

Mit dem in dieser Anleitung beschriebenen Client SDK für Android können Sie auf die Gemini Pro-Modelle, die auf den Servern von Google ausgeführt werden. Für Anwendungsfälle, bei denen der Verarbeitung sensibler Daten, der Offlineverfügbarkeit oder der häufig verwendeten Aufrufabfolgen von Webseiten verwenden, ist es unter Umständen sinnvoll, auf Gemini Nano zuzugreifen. die auf dem Gerät ausgeführt wird. Weitere Informationen finden Sie in der Anleitung auf dem Android-Gerät

Vorbereitung

In dieser Anleitung wird davon ausgegangen, dass Sie mit Android Studio vertraut sind, um Android-Apps zu entwickeln.

Um diese Anleitung abzuschließen, müssen Ihre Entwicklungsumgebung und Android-Apps erfüllen die folgenden Anforderungen:

  • 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. umfasst das Einrichten Ihres API-Schlüssels, das Hinzufügen der SDK-Abhängigkeiten zu Ihrem Android-Gerät und die Initialisierung des Modells.

API-Schlüssel einrichten

Zur Verwendung der Gemini API benötigen Sie einen API-Schlüssel. Falls Sie noch keines haben, einen Schlüssel in Google AI Studio zu erstellen.

API-Schlüssel anfordern

API-Schlüssel sichern

Es wird dringend empfohlen, keinen API-Schlüssel in Ihre Version einzuchecken. zu steuern. Speichern Sie sie stattdessen in einer local.properties-Datei. (das sich im Stammverzeichnis Ihres Projekts befindet, aber von der Version ausgeschlossen ist Steuerung) und verwenden Sie dann die 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 bei allen Snippets in dieser Anleitung angewendet. Wenn Sie die Implementierung des Secrets Gradle-Plug-ins sehen möchten, können Sie sich die Beispiel-App für dieses SDK oder die neueste Vorabversion von Android Studio Iguana mit einer Vorlage Gemini API Starter (einschließlich der Datei local.properties für den Einstieg).

SDK-Abhängigkeit zum Projekt hinzufügen

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

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

  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

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 die multimodale Eingabe. In diesem Handbuch finden Sie die Anweisungen für die Implementierungsliste das empfohlene Modell für jeden Anwendungsfall.

Gängige Anwendungsfälle implementieren

Ihr Projekt ist nun eingerichtet. Jetzt können Sie mit der Gemini API experimentieren, um verschiedene Anwendungsfälle zu implementieren:

Text aus reiner Texteingabe generieren

Wenn die Prompt-Eingabe nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder den Gemini 1.0 Pro-Modell mit generateContent zum Generieren von Textausgabe:

Kotlin

generateContent() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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

generateContent() gibt ListenableFuture zurück. Wenn mit dieser API nicht vertraut sind, finden Sie in der Android-Dokumentation Mit 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, die multimodale Eingaben verarbeiten können. (Gemini 1.5-Modelle), sodass Sie sowohl Text als auch Bilder eingeben können. Achten Sie darauf, Sehen Sie sich 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 mit generateContent zum Generieren der Textausgabe:

Kotlin

generateContent() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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

generateContent() gibt ListenableFuture zurück. Wenn mit dieser API nicht vertraut sind, finden Sie in der Android-Dokumentation Mit 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 erstellen (Chat)

Mit Gemini kannst du Unterhaltungen im freien Format über mehrere Runden hinweg führen. Die Das SDK vereinfacht den Prozess, da es den Status der Unterhaltung verwaltet. Im Gegensatz zu mit generateContent müssen Sie den Unterhaltungsverlauf nicht speichern, sich selbst zu zeigen.

Wenn Sie eine Unterhaltung mit mehreren Teilnehmern (z. B. einen Chat) erstellen möchten, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen. Verwenden Sie dann sendMessage(), um eine neue Nutzernachricht zu senden, die auch den und die Antwort auf das Chatprotokoll.

Es gibt zwei mögliche Optionen für role, die mit den Inhalten in einer Gespräch:

  • user: Die Rolle, die die Aufforderungen bereitstellt. Dieser Wert ist der Standardwert für sendMessage Anrufe.

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

Kotlin

generateContent() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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

generateContent() gibt ListenableFuture zurück. Wenn mit dieser API nicht vertraut sind, finden Sie in der Android-Dokumentation Mit 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.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 der gesamten Generierung eine Antwort zurück . Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf die gesamte Ergebnis. Verwenden Sie stattdessen Streaming, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Streaming mit generateContentStream, um Text über einen Text- und Bild-Eingabe-Prompt zu generieren.

Kotlin

generateContentStream() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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 zurück aus den Reaktiven Streams Bibliothek.

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

generateContentStream() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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 zurück aus den Reaktiven Streams Bibliothek.

// 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 damit Sie sich mit der Nutzung der Gemini API vertraut machen können. In diesem Abschnitt werden einige Anwendungsfälle, die als fortgeschrittener betrachtet werden können.

Funktionsaufrufe

Funktionsaufrufe erleichtern Ihnen, Ausgaben für strukturierte Daten generativen Modellen. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zu senden. Mit anderen Worten, Funktionsaufrufe helfen generative Modelle mit externen Systemen verbinden, damit die generierten Inhalte aktuelle und korrekte Informationen enthält. Weitere Informationen finden Sie in der Anleitung für Funktionsaufrufe.

Anzahl der Tokens

Bei langen Prompts kann es hilfreich sein, Tokens zu zählen, bevor sie gesendet werden an das Modell übergeben. Die folgenden Beispiele zeigen, wie countTokens() verwendet wird für verschiedene Anwendungsfälle:

Kotlin

countTokens() ist eine Sperrfunktion und muss von einem Coroutine-Bereich aufgerufen werden. Wenn Sie mit Coroutines nicht vertraut sind, lesen Sie Kotlin-Koroutinen 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

countTokens() gibt ListenableFuture zurück. Wenn mit dieser API nicht vertraut sind, finden Sie in der Android-Dokumentation Mit 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 Inhaltserstellung

Sie können die Generierung von Inhalten steuern, indem Sie Modellparameter konfigurieren und die Sicherheitseinstellungen.

Modellparameter konfigurieren

Jeder Prompt, den Sie an das Modell senden, enthält Parameterwerte, mit denen generiert das Modell eine Antwort. Das Modell kann für verschiedene Parameterwerte unterschiedliche Ergebnisse generieren. Weitere Informationen zu Modellparameter:

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

Mithilfe der Sicherheitseinstellungen kannst du anpassen, wie wahrscheinlich es ist, dass du Antworten erhältst, als schädlich eingestuft werden. Standardmäßig blockieren die Sicherheitseinstellungen Inhalte mit der Einstellung „Medium“ und/oder eine hohe Wahrscheinlichkeit, dass sie in allen Dimensionen unsicher sind. Weitere Informationen 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 mehrere Modellvarianten für unterschiedliche Anforderungen wie Eingabetypen und -komplexität, Implementierungen für Chat und andere Dialogsprachaufgaben und Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen

  • Mit dem in dieser Anleitung beschriebenen Client SDK für Android können Sie auf die Gemini Pro-Modelle, die auf den Servern von Google ausgeführt werden. Für Anwendungsfälle, bei denen der Verarbeitung sensibler Daten, der Offlineverfügbarkeit oder der häufig verwendeten Aufrufabfolgen von Webseiten verwenden, ist es unter Umständen sinnvoll, auf Gemini Nano zuzugreifen. die auf dem Gerät ausgeführt wird. Weitere Informationen finden Sie in der Anleitung auf dem Android-Gerät