Samouczek: pierwsze kroki z interfejsem Gemini API


Z tego samouczka dowiesz się, jak uzyskać dostęp do interfejsu Gemini API bezpośrednio z aplikacji na Androida za pomocą pakietu SDK klienta AI od Google na Androida. Możesz użyć tego pakietu SDK klienta, jeśli nie chcesz korzystać bezpośrednio z interfejsów API REST lub kodu po stronie serwera (np. Pythona) w celu uzyskania dostępu do modeli Gemini w aplikacji na Androida.

Z tego samouczka dowiesz się, jak:

Dodatkowo ten samouczek zawiera sekcje o zaawansowanych przypadkach użycia (takich jak tokeny liczenia) oraz opcje kontrolowania generowania treści.

Rozważ uzyskanie dostępu do Gemini na urządzeniu

Opisany w tym samouczku pakiet SDK klienta na Androida umożliwia dostęp do modeli Gemini Pro, które działają na serwerach Google. W przypadkach użycia związanych z przetwarzaniem danych wrażliwych, dostępności w trybie offline lub w celu obniżenia kosztów często używanych przepływów użytkowników warto skorzystać z usługi Gemini Nano, która działa na urządzeniu. Więcej informacji znajdziesz w samouczku na urządzeniu z Androidem.

Wymagania wstępne

W tym samouczku zakładamy, że wiesz już, jak używać Android Studio do tworzenia aplikacji na Androida.

Aby ukończyć ten samouczek, upewnij się, że Twoje środowisko programistyczne i aplikacja na Androida spełniają te wymagania:

  • Android Studio (najnowsza wersja)
  • Aplikacja na Androida musi być kierowana na interfejs API na poziomie 21 lub wyższym.

Konfigurowanie projektu

Zanim wywołasz Gemini API, musisz skonfigurować swój projekt na Androida, który obejmuje skonfigurowanie klucza interfejsu API, dodanie zależności pakietu SDK do projektu Android i zainicjowanie modelu.

Konfigurowanie klucza interfejsu API

Aby korzystać z Gemini API, potrzebujesz klucza interfejsu API. Jeśli nie masz jeszcze klucza, utwórz go w Google AI Studio.

Uzyskiwanie klucza interfejsu API

Zabezpiecz klucz interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w systemie kontroli wersji. Zamiast tego zapisz go w pliku local.properties (który znajduje się w katalogu głównym projektu, ale nie jest objęty kontrolą wersji), a potem użyj wtyczki do Gradle obiektów tajnych dla Androida, aby odczytać klucz interfejsu API jako zmienną konfiguracji kompilacji.

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;

Wszystkie fragmenty kodu w tym samouczku korzystają z tej sprawdzonej metody. Jeśli chcesz zobaczyć implementację wtyczki Gradle obiektów tajnych, możesz zapoznać się z przykładową aplikacją dla tego pakietu SDK lub skorzystać z najnowszej wersji testowej Androida Studio Iguana, która zawiera szablon Gemini API Starter (zawierający plik local.properties).

Dodaj zależność pakietu SDK do projektu

  1. W pliku konfiguracji Gradle modułu (na poziomie aplikacji) (np. <project>/<app-module>/build.gradle.kts) dodaj zależność z pakietem SDK Google AI na Androida:

    Kotlin

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

    Java

    W przypadku języka Java musisz dodać 2 dodatkowe biblioteki.

    dependencies {
        // ... other androidx dependencies
    
        // add the dependency for the Google AI client SDK for Android
        implementation("com.google.ai.client.generativeai:generativeai:0.7.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. Zsynchronizuj swój projekt na Androida z plikami Gradle.

Zainicjuj model generatywny

Zanim będzie można wykonywać wywołania interfejsu API, musisz zainicjować model generatywny:

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

W przypadku Javy musisz również zainicjować obiekt GenerativeModelFutures.

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

Podczas określania modelu pamiętaj o tych kwestiach:

  • Użyj modelu dopasowanego do Twojego przypadku użycia (np. gemini-1.5-flash służy do wprowadzania multimodalnych danych wejściowych). W tym przewodniku instrukcje dotyczące poszczególnych implementacji wskazują zalecany model w poszczególnych przypadkach użycia.

Wdrażanie typowych przypadków użycia

Po skonfigurowaniu projektu możesz zacząć korzystać z Gemini API, aby wdrażać różne przypadki użycia:

Generuj tekst na podstawie samego tekstu

Jeśli prompt zawiera tylko tekst, do wygenerowania tekstu wyjściowego użyj modelu Gemini 1.5 lub Gemini 1.0 Pro z funkcją generateContent:

Kotlin

Pamiętaj, że generateContent() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Pamiętaj, że generateContent() zwraca wartość ListenableFuture. Jeśli nie znasz tego interfejsu API, zapoznaj się z dokumentacją Androida dotyczącą korzystania z interfejsu 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);

Generuj tekst na podstawie danych wejściowych z tekstem i obrazem (multimodalny)

Gemini udostępnia różne modele, które obsługują dane wejściowe multimodalne (modele Gemini 1.5), dzięki czemu można w nich wpisywać zarówno tekst, jak i obrazy. Zapoznaj się z wymaganiami dotyczącymi obrazów w promptach.

Jeśli prompt zawiera zarówno tekst, jak i obrazy, użyj modelu Gemini 1.5 z funkcją generateContent, aby wygenerować tekst:

Kotlin

Pamiętaj, że generateContent() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Pamiętaj, że generateContent() zwraca wartość ListenableFuture. Jeśli nie znasz tego interfejsu API, zapoznaj się z dokumentacją Androida dotyczącą korzystania z interfejsu 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);

Tworzenie rozmów wieloetapowych (czat)

Za pomocą Gemini możesz prowadzić swobodne rozmowy na różnych etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, więc w przeciwieństwie do generateContent nie musisz samodzielnie zapisywać historii rozmowy.

Aby utworzyć rozmowę wieloetapową (np. czat), użyj modelu Gemini 1.5 lub Gemini 1.0 Pro i zainicjuj czat, dzwoniąc pod numer startChat(). Następnie użyj sendMessage(), aby wysłać nową wiadomość użytkownika. Ta wiadomość i odpowiedź zostaną też dołączone do historii czatu.

Istnieją 2 opcje pola role związane z treścią rozmowy:

  • user: rola, która dostarcza prompty. Jest to wartość domyślna w przypadku wywołań funkcji sendMessage.

  • model: rola, która dostarcza odpowiedzi. Tej roli można używać podczas wywoływania funkcji startChat() przy użyciu istniejącego konta history.

Kotlin

Pamiętaj, że generateContent() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Pamiętaj, że generateContent() zwraca wartość ListenableFuture. Jeśli nie znasz tego interfejsu API, zapoznaj się z dokumentacją Androida dotyczącą korzystania z interfejsu 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);

Używaj strumieniowania, aby przyspieszyć interakcje

Domyślnie model zwraca odpowiedź po zakończeniu całego procesu generowania. Możesz przyspieszyć interakcje, nie czekając na cały wynik. Zamiast tego użyj strumieniowania do obsługi częściowych wyników.

Poniższy przykład pokazuje, jak wdrożyć strumieniowanie za pomocą narzędzia generateContentStream, aby generować tekst na podstawie promptu zawierającego tekst i obraz.

Kotlin

Pamiętaj, że generateContentStream() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Metody strumieniowego przesyłania danych w języku Java w tym pakiecie SDK zwracają typ Publisher z biblioteki Strumienie reaktywne.

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

Podobną metodę możesz zastosować w przypadkach użycia samego tekstu i czatu:

Kotlin

Pamiętaj, że generateContentStream() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Metody strumieniowego przesyłania danych w języku Java w tym pakiecie SDK zwracają typ Publisher z biblioteki Strumienie reaktywne.

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

Wdrażanie zaawansowanych przypadków użycia

Typowe przypadki użycia opisane w poprzedniej sekcji tego samouczka pomagają opanować interfejs Gemini API. W tej sekcji opisujemy niektóre przypadki użycia, które mogą być uznane za bardziej zaawansowane.

Wywoływanie funkcji

Wywołania funkcji ułatwiają uzyskiwanie danych wyjściowych uporządkowanych danych z modeli generatywnych. Następnie możesz używać tych danych wyjściowych do wywoływania innych interfejsów API i zwracania odpowiednich danych odpowiedzi do modelu. Inaczej mówiąc, wywołanie funkcji pomaga połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały najbardziej aktualne i dokładne informacje. Więcej informacji znajdziesz w samouczku na temat wywoływania funkcji.

Policz tokeny

W przypadku długich promptów liczenie tokenów przed wysłaniem jakiejkolwiek treści do modelu może być przydatne. Poniższe przykłady pokazują, jak używać countTokens() w różnych przypadkach:

Kotlin

Pamiętaj, że countTokens() to funkcja zawieszania i musi być wywoływana z zakresu Coroutine. Jeśli nie znasz jeszcze programu Coroutines, przeczytaj artykuł Kotlin Coroutines na Androidzie.

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

Pamiętaj, że countTokens() zwraca wartość ListenableFuture. Jeśli nie znasz tego interfejsu API, zapoznaj się z dokumentacją Androida dotyczącą korzystania z interfejsu 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]));

Opcje kontrolowania generowania treści

Możesz kontrolować generowanie treści, konfigurując parametry modelu lub używając ustawień bezpieczeństwa.

Skonfiguruj parametry modelu

Każdy prompt wysyłany do modelu zawiera wartości parametrów, które kontrolują sposób generowania odpowiedzi przez model. Model może generować różne wyniki w zależności od wartości parametrów. Dowiedz się więcej o parametrach modelu.

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

Korzystanie z ustawień bezpieczeństwa

Korzystając z ustawień bezpieczeństwa, możesz dostosować prawdopodobieństwo otrzymywania odpowiedzi, które mogą być uznane za szkodliwe. Domyślnie ustawienia bezpieczeństwa blokują treści o średnim prawdopodobieństwie lub z dużym prawdopodobieństwem, że mogą być niebezpieczne we wszystkich wymiarach. Dowiedz się więcej o ustawieniach bezpieczeństwa.

Aby skonfigurować jedno ustawienie bezpieczeństwa:

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

Możesz też skonfigurować więcej niż jedno ustawienie bezpieczeństwa:

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

Co dalej

  • Projektowanie promptów to proces tworzenia promptów, które wywołują pożądaną odpowiedź z modeli językowych. Napisanie dobrze uporządkowanych promptów jest niezbędną częścią gwarantowania dokładnych, wysokiej jakości odpowiedzi na podstawie modelu językowego. Poznaj sprawdzone metody pisania promptów.

  • Gemini oferuje kilka wersji modelu, aby sprostać różnym przypadkom użycia, takim jak typy danych wejściowych i złożoność, implementacje czatu lub innych zadań związanych z językiem w oknie dialogowym oraz ograniczenia rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.

  • Opisany w tym samouczku pakiet SDK klienta na Androida umożliwia dostęp do modeli Gemini Pro, które działają na serwerach Google. W przypadkach użycia związanych z przetwarzaniem danych wrażliwych, dostępności w trybie offline lub w celu obniżenia kosztów często używanych przepływów użytkowników warto skorzystać z usługi Gemini Nano, która działa na urządzeniu. Więcej informacji znajdziesz w samouczku na urządzeniu z Androidem.