Ce tutoriel explique comment accéder à l'API Gemini directement depuis votre application Android à l'aide du SDK client Google AI pour Android. Vous pouvez utiliser ce SDK client si vous ne souhaitez pas travailler directement avec les API REST ni avec du code côté serveur (comme Python) pour accéder aux modèles Gemini dans votre application Android.
Dans ce tutoriel, vous allez apprendre à effectuer les opérations suivantes:
- Configurer votre projet, y compris votre clé API
- Générer du texte à partir d'une entrée textuelle
- Générer du texte à partir d'une entrée de texte et d'image (multimodal)
- Créer des conversations multitours (chat)
- Utiliser le streaming pour des interactions plus rapides
En outre, ce tutoriel contient des sections sur des cas d'utilisation avancés (comme le compte des jetons) ainsi que des options de contrôle de la génération de contenu.
Envisagez d'accéder à Gemini sur l'appareil
Le SDK client pour Android décrit dans ce tutoriel vous permet d'accéder aux modèles Gemini Pro qui s'exécutent sur les serveurs Google. Pour les cas d'utilisation impliquant le traitement de données sensibles, la disponibilité hors connexion ou les économies liées aux parcours utilisateur fréquemment utilisés, vous pouvez envisager d'accéder à Gemini Nano, qui s'exécute sur l'appareil. Pour en savoir plus, consultez le tutoriel Android (sur l'appareil).
Conditions préalables
Dans ce tutoriel, nous partons du principe que vous savez utiliser Android Studio pour développer des applications Android.
Pour suivre ce tutoriel, assurez-vous que votre environnement de développement et votre application Android répondent aux exigences suivantes:
- Android Studio (dernière version)
- Votre application Android doit cibler le niveau d'API 21 ou supérieur.
Configurer votre projet
Avant d'appeler l'API Gemini, vous devez configurer votre projet Android, ce qui inclut la configuration de votre clé API, l'ajout des dépendances du SDK à votre projet Android et l'initialisation du modèle.
Configurer votre clé API
Pour utiliser l'API Gemini, vous avez besoin d'une clé API. Si ce n'est pas déjà fait, créez une clé dans Google AI Studio.
Sécuriser votre clé API
Il est fortement recommandé de ne pas vérifier de clé API dans votre système de contrôle des versions. Vous devez la stocker dans un fichier local.properties
(qui se trouve dans le répertoire racine de votre projet, mais exclu du contrôle des versions), puis utiliser le plug-in Secrets Gradle pour Android pour lire votre clé API en tant que variable de configuration de compilation.
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;
Tous les extraits de ce tutoriel s'appuient sur cette bonne pratique. Si vous souhaitez également voir l'implémentation du plug-in Secrets Gradle, vous pouvez consulter l'application exemple de ce SDK ou utiliser la dernière version preview d'Android Studio Iguana, qui propose un modèle Gemini API Starter (qui inclut le fichier local.properties
pour vous aider à démarrer).
Ajouter la dépendance SDK à votre projet
Dans le fichier de configuration Gradle de votre module (au niveau de l'application) (comme
<project>/<app-module>/build.gradle.kts
), ajoutez la dépendance pour le SDK Google AI pour 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
Pour Java, vous devez ajouter deux bibliothèques supplémentaires.
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") }
Synchronisez votre projet Android avec les fichiers Gradle.
Initialiser le modèle génératif
Avant de pouvoir effectuer des appels d'API, vous devez initialiser le modèle génératif:
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
Pour Java, vous devez également initialiser l'objet 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);
Lorsque vous spécifiez un modèle, tenez compte des points suivants:
Utilisez un modèle spécifique à votre cas d'utilisation (par exemple,
gemini-1.5-flash
est destiné à l'entrée multimodale). Dans ce guide, les instructions correspondant à chaque implémentation répertorient le modèle recommandé pour chaque cas d'utilisation.
Mettre en œuvre des cas d'utilisation courants
Maintenant que votre projet est configuré, vous pouvez explorer l'utilisation de l'API Gemini pour implémenter différents cas d'utilisation:
- Générer du texte à partir d'une entrée textuelle
- Générer du texte à partir d'une entrée de texte et d'image (multimodal)
- Créer des conversations multitours (chat)
- Utiliser le streaming pour des interactions plus rapides
Générer du texte à partir d'une entrée textuelle uniquement
Lorsque l'entrée de la requête n'inclut que du texte, utilisez un modèle Gemini 1.5 ou Gemini 1.0 Pro avec generateContent
pour générer une sortie textuelle:
Kotlin
Notez que generateContent()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Notez que generateContent()
renvoie un ListenableFuture
. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un 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);
Générer du texte à partir d'une entrée texte et image (multimodal)
Gemini propose plusieurs modèles capables de gérer la saisie multimodale (modèles Gemini 1.5) afin que vous puissiez saisir à la fois du texte et des images. Veillez à consulter les exigences concernant les images pour les requêtes.
Lorsque l'entrée de la requête inclut à la fois du texte et des images, utilisez un modèle Gemini 1.5 avec generateContent
pour générer une sortie textuelle:
Kotlin
Notez que generateContent()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Notez que generateContent()
renvoie un ListenableFuture
. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un 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);
Développer des conversations multitours (chat)
Avec Gemini, vous pouvez construire des conversations libres dans plusieurs tours. Le SDK simplifie le processus en gérant l'état de la conversation. Ainsi, contrairement à generateContent
, vous n'avez pas besoin de stocker vous-même l'historique de la conversation.
Pour créer une conversation multitours (comme un chat), utilisez un modèle Gemini 1.5 ou Gemini 1.0 Pro, puis initialisez la discussion en appelant startChat()
.
Utilisez ensuite sendMessage()
pour envoyer un nouveau message à l'utilisateur, qui ajoutera également le message et la réponse à l'historique des discussions.
Il existe deux options possibles pour role
associées au contenu d'une conversation:
user
: rôle qui fournit les invites. Cette valeur est la valeur par défaut pour les appelssendMessage
.model
: rôle qui fournit les réponses. Ce rôle peut être utilisé lorsque vous appelezstartChat()
avec unhistory
existant.
Kotlin
Notez que generateContent()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Notez que generateContent()
renvoie un ListenableFuture
. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un 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);
Utiliser le streaming pour des interactions plus rapides
Par défaut, le modèle renvoie une réponse à la fin du processus de génération. Vous pouvez obtenir des interactions plus rapides en n'attendant pas l'intégralité du résultat et en utilisant plutôt le traitement par flux pour gérer les résultats partiels.
L'exemple suivant montre comment implémenter un flux de données avec generateContentStream
pour générer du texte à partir d'une requête d'entrée contenant du texte et une image.
Kotlin
Notez que generateContentStream()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Les méthodes de streaming Java de ce SDK renvoient un type Publisher
de la bibliothèque Reactive Streams.
// 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);
}
});
Vous pouvez utiliser une approche similaire pour la saisie textuelle et le chat:
Kotlin
Notez que generateContentStream()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Les méthodes de streaming Java de ce SDK renvoient un type Publisher
de la bibliothèque Reactive Streams.
// 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
});
Implémenter des cas d'utilisation avancés
Les cas d'utilisation courants décrits dans la section précédente de ce tutoriel vous aident à vous familiariser avec l'API Gemini. Cette section décrit certains cas d'utilisation pouvant être considérés comme plus avancés.
Appel de fonction
L'appel de fonction vous permet d'obtenir plus facilement des sorties de données structurées à partir de modèles génératifs. Vous pouvez ensuite utiliser ces sorties pour appeler d'autres API et renvoyer les données de réponse pertinentes au modèle. En d'autres termes, l'appel de fonction vous aide à connecter des modèles génératifs à des systèmes externes afin que le contenu généré inclue les informations les plus récentes et les plus précises. Pour en savoir plus, consultez le tutoriel sur l'appel de fonction.
Compter les jetons
Lorsque vous utilisez de longues requêtes, il peut être utile de compter les jetons avant d'envoyer du contenu au modèle. Les exemples suivants montrent comment utiliser countTokens()
pour différents cas d'utilisation:
Kotlin
Notez que countTokens()
est une fonction de suspension et doit être appelée à partir d'un champ d'application de coroutine. Si vous ne connaissez pas les coroutines, consultez la page Coroutines Kotlin sur 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
Notez que countTokens()
renvoie un ListenableFuture
. Si vous ne connaissez pas cette API, consultez la documentation Android sur l'utilisation d'un 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]));
Options pour contrôler la génération de contenu
Vous pouvez contrôler la génération de contenu en configurant les paramètres du modèle et en utilisant les paramètres de sécurité.
Configurer les paramètres du modèle
Chaque requête que vous envoyez au modèle inclut des valeurs de paramètre qui contrôlent la manière dont le modèle génère une réponse. Le modèle peut générer différents résultats pour différentes valeurs de paramètre. En savoir plus sur les paramètres de modèle
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);
Utiliser les paramètres de sécurité
Vous pouvez utiliser les paramètres de sécurité pour ajuster la probabilité d'obtenir des réponses susceptibles d'être considérées comme dangereuses. Par défaut, les paramètres de sécurité bloquent le contenu dont la probabilité est moyenne et/ou élevée d'être dangereux pour toutes les dimensions. En savoir plus sur les paramètres de sécurité
Pour définir un paramètre de sécurité, procédez comme suit:
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);
Vous pouvez également définir plusieurs paramètres de sécurité:
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);
Étapes suivantes
La conception de requêtes est le processus de création de requêtes qui permettent d'obtenir la réponse souhaitée en utilisant des modèles de langage. Pour rédiger des réponses précises et de haute qualité à partir d'un modèle de langage, il est essentiel de rédiger des requêtes bien structurées. Découvrez les bonnes pratiques pour rédiger des requêtes.
Gemini propose plusieurs variantes de modèles pour répondre aux besoins de différents cas d'utilisation, tels que les types et la complexité des entrées, les implémentations de chat ou d'autres tâches liées au langage de dialogue, ainsi que les contraintes de taille. En savoir plus sur les modèles Gemini disponibles
Le SDK client pour Android décrit dans ce tutoriel vous permet d'accéder aux modèles Gemini Pro qui s'exécutent sur les serveurs Google. Pour les cas d'utilisation impliquant le traitement de données sensibles, la disponibilité hors connexion ou les économies liées aux parcours utilisateur fréquemment utilisés, vous pouvez envisager d'accéder à Gemini Nano, qui s'exécute sur l'appareil. Pour en savoir plus, consultez le tutoriel Android (sur l'appareil).