Tutoriel: Premiers pas avec l'API Gemini

<ph type="x-smartling-placeholder"></ph>


Ce tutoriel explique comment accéder à l'API Gemini directement depuis votre Application Android utilisant le SDK client Google AI pour Android Vous pouvez utiliser cette SDK client si vous ne souhaitez pas travailler directement avec les API REST ou 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:

En outre, ce tutoriel contient des sections sur des cas d'utilisation avancés (comme compter les jetons), ainsi que des options 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 Modèles Gemini Pro qui s'exécutent sur les serveurs de Google. Pour les cas d'utilisation impliquant le traitement de données sensibles, la disponibilité hors connexion ou les économies parcours utilisateur fréquents, envisagez d'accéder à Gemini Nano qui s'exécute sur l'appareil. Pour en savoir plus, consultez les Tutoriel Android (sur l'appareil)

Prérequis

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 doit disposer de la configuration suivante:

  • 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, qui vous devez configurer votre clé API, ajouter les dépendances du SDK à votre application Android le projet et l'initialisation du modèle.

Configurer votre clé API

Pour utiliser l'API Gemini, vous avez besoin d'une clé API. Si vous n'en avez pas encore, créer une clé dans Google AI Studio.

Obtenir une clé API

Sécuriser votre clé API

Il est fortement recommandé de ne pas vérifier de clé API dans votre version système de contrôle. Stockez-les plutôt dans un fichier local.properties. (qui se trouve dans le répertoire racine de votre projet, mais qui est exclu de la version commande), puis utilisez la commande 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. De plus, si vous souhaitez voir l'implémentation du plug-in Secrets Gradle, consultez la application exemple pour ce SDK ou utilisez la dernière version preview d'Android Studio Iguana, qui dispose d'un Modèle Gemini API Starter (qui inclut le fichier local.properties pour vous aider à démarrer).

Ajouter la dépendance SDK à votre projet

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

  2. 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 pour chaque 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 utiliser l'API Gemini pour : pour implémenter différents cas d'utilisation:

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 la Modèle Gemini 1.0 Pro avec generateContent pour générer une sortie textuelle:

Kotlin

Notez que generateContent() est une fonction de suspension qui doit être appelé à 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 Utiliser 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 fournit différents modèles pouvant gérer la saisie multimodale (modèles Gemini 1.5) pour que vous puissiez saisir à la fois du texte et des images. Veillez à consultez les exigences concernant les images pour les requêtes.

Lorsque 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 qui doit être appelé à 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 Utiliser 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. La Le SDK simplifie le processus en gérant l'état de la conversation. avec generateContent, vous n'avez pas besoin de stocker l'historique de la conversation vous-même.

Pour créer une conversation multitours (un chat, par exemple), utilisez un modèle Gemini 1.5 ou la Gemini 1.0 Pro, puis initialisez la discussion en appelant startChat(). Utilisez ensuite sendMessage() pour envoyer un nouveau message utilisateur, qui ajoutera également le 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 sendMessage appels.

  • model: rôle qui fournit les réponses. Ce rôle peut être utilisé Appel de startChat() avec history existant

Kotlin

Notez que generateContent() est une fonction de suspension qui doit être appelé à 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 Utiliser 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 de la génération processus. Vous pouvez obtenir des interactions plus rapides en n'attendant pas l'intégralité et utilisez 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 de texte et d'image.

Kotlin

Notez que generateContentStream() est une fonction de suspension qui doit être appelé à 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 à partir des flux réactifs bibliothèque.

// 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 qui doit être appelé à 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 à partir des flux réactifs bibliothèque.

// 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 serez à l'aise avec l'utilisation de l'API Gemini. Cette section décrit certaines des 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 données structurées en sortie les 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 aide vous connectez des modèles génératifs à des systèmes externes inclut 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 invites, 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 qui doit être appelé à 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 Utiliser 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 paramètres de sécurité.

Configurer les paramètres du modèle

Chaque requête envoyée au modèle inclut des valeurs de paramètre qui contrôlent la façon 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 Paramètres du 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 peuvent être considérés comme dangereux. Par défaut, les paramètres de sécurité bloquent le contenu comportant et/ou une probabilité élevée d'être un contenu dangereux pour toutes les dimensions. Apprendre 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);

Étape suivante

  • 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 usages les types d'entrées et leur complexité, les implémentations pour le chat ou d'autres les tâches liées au langage de boîte de dialogue et 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 Modèles Gemini Pro qui s'exécutent sur les serveurs de Google. Pour les cas d'utilisation impliquant le traitement de données sensibles, la disponibilité hors connexion ou les économies parcours utilisateur fréquents, envisagez d'accéder à Gemini Nano qui s'exécute sur l'appareil. Pour en savoir plus, consultez les Tutoriel Android (sur l'appareil)