Ce tutoriel explique comment accéder à l'API Gemini pour votre application Dart ou Flutter à l'aide du SDK Dart Google AI. Vous pouvez utiliser ce SDK si vous ne souhaitez pas travailler directement avec les API REST pour accéder aux modèles Gemini dans votre application.
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 de texte uniquement
- Générer du texte à partir d'une entrée de texte et d'image (multimodale)
- Créer des conversations multitours (chat)
- Utiliser le streaming pour des interactions plus rapides
Ce tutoriel contient également des sections sur des cas d'utilisation avancés (tels que les représentations vectorielles continues et les jetons de comptage), ainsi que sur les options de contrôle de la génération de contenu.
Prérequis
Dans ce tutoriel, nous partons du principe que vous savez comment créer des applications avec Dart.
Pour suivre ce tutoriel, assurez-vous que votre environnement de développement répond aux exigences suivantes:
- Dart 3.2.0 et versions ultérieures
Configurer votre projet
Avant d'appeler l'API Gemini, vous devez configurer votre projet, ce qui comprend la configuration de votre clé API, l'ajout du SDK aux dépendances de l'éditeur 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, créez-en une dans Google AI Studio.
Sécuriser votre clé API
Assurez la sécurité de votre clé API. Nous vous recommandons vivement de ne pas inclure la clé API directement dans votre code ni de vérifier les fichiers qui la contiennent dans les systèmes de contrôle des versions. Utilisez plutôt un magasin de secrets pour votre clé API.
Tous les extraits de ce tutoriel supposent que vous accédez à votre clé API en tant que variable d'environnement de processus. Si vous développez une application Flutter, vous pouvez utiliser String.fromEnvironment et transmettre --dart-define=API_KEY=$API_KEY à flutter build ou flutter run pour la compiler avec la clé API, car l'environnement de processus sera différent lors de l'exécution de l'application.
Installer le package SDK
Pour utiliser l'API Gemini dans votre application, vous devez add le package google_generative_ai sur votre application Dart ou Flutter:
Dart
dart pub add google_generative_ai
Flutter
flutter pub add google_generative_ai
Initialiser le modèle génératif
Avant de pouvoir effectuer des appels d'API, vous devez importer et initialiser le modèle génératif.
import 'package:google_generative_ai/google_generative_ai.dart';
// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
print('No \$API_KEY environment variable');
exit(1);
}
final model = GenerativeModel(model: 'MODEL_NAME', apiKey: apiKey);
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-pro-visionest destiné à l'entrée multimodale). Dans ce guide, les instructions pour chaque implémentation listent le modèle recommandé pour chaque cas d'utilisation.
Implémenter des cas d'utilisation courants
Maintenant que votre projet est configuré, vous pouvez découvrir comment utiliser l'API Gemini pour mettre en œuvre différents cas d'utilisation:
- Générer du texte à partir d'une entrée de texte uniquement
- Générer du texte à partir d'une entrée de texte et d'image (multimodale)
- Créer des conversations multitours (chat)
- Utiliser le streaming pour des interactions plus rapides
Dans la section sur les cas d'utilisation avancés, vous trouverez des informations sur l'API Gemini et les représentations vectorielles continues.
Générer du texte à partir d'une entrée de texte uniquement
Lorsque l'entrée de la requête n'inclut que du texte, utilisez le modèle gemini-pro avec la méthode generateContent pour générer une sortie textuelle:
import 'dart:io';
import 'package:google_generative_ai/google_generative_ai.dart';
void main() async {
// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
print('No \$API_KEY environment variable');
exit(1);
}
// For text-only input, use the gemini-pro model
final model = GenerativeModel(model: 'gemini-pro', apiKey: apiKey);
final content = [Content.text('Write a story about a magic backpack.')];
final response = await model.generateContent(content);
print(response.text);
}
Générer du texte à partir d'une entrée de texte et d'image (multimodale)
Gemini fournit un modèle multimodal (gemini-pro-vision), qui vous permet de saisir à la fois du texte et des images. Veillez à consulter les exigences concernant les images pour les entrées.
Lorsque l'entrée de la requête comprend à la fois du texte et des images, utilisez le modèle gemini-pro-vision avec la méthode generateContent pour générer une sortie textuelle:
import 'dart:io';
import 'package:google_generative_ai/google_generative_ai.dart';
void main() async {
// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
print('No \$API_KEY environment variable');
exit(1);
}
// For text-and-image input (multimodal), use the gemini-pro-vision model
final model = GenerativeModel(model: 'gemini-pro-vision', apiKey: apiKey);
final (firstImage, secondImage) = await (
File('image0.jpg').readAsBytes(),
File('image1.jpg').readAsBytes()
).wait;
final prompt = TextPart("What's different between these pictures?");
final imageParts = [
DataPart('image/jpeg', firstImage),
DataPart('image/jpeg', secondImage),
];
final response = await model.generateContent([
Content.multi([prompt, ...imageParts])
]);
print(response.text);
}
Créer des conversations multitours (chat)
Gemini vous permet de créer des conversations de forme libre sur 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 l'historique de la conversation vous-même.
Pour créer une conversation multitour (telle qu'un chat), utilisez le modèle gemini-pro, puis initialisez le chat en appelant startChat(). Utilisez ensuite sendMessage() pour envoyer un nouveau message utilisateur, qui ajoutera également le message et la réponse à l'historique des discussions.
Deux options sont possibles pour role associé au contenu d'une conversation:
user: rôle qui fournit les invites. Cette valeur est la valeur par défaut pour les appelssendMessage. La fonction génère une exception si un autre rôle est transmis.model: rôle qui fournit les réponses. Ce rôle peut être utilisé lorsque vous appelezstartChat()avec lehistoryexistant.
import 'dart:io';
import 'package:google_generative_ai/google_generative_ai.dart';
Future<void> main() async {
// Access your API key as an environment variable (see "Set up your API key" above)
final apiKey = Platform.environment['API_KEY'];
if (apiKey == null) {
print('No \$API_KEY environment variable');
exit(1);
}
// For text-only input, use the gemini-pro model
final model = GenerativeModel(
model: 'gemini-pro',
apiKey: apiKey,
generationConfig: GenerationConfig(maxOutputTokens: 100));
// Initialize the chat
final chat = model.startChat(history: [
Content.text('Hello, I have 2 dogs in my house.'),
Content.model([TextPart('Great to meet you. What would you like to know?')])
]);
var content = Content.text('How many paws are in my house?');
var response = await chat.sendMessage(content);
print(response.text);
}
Utiliser le streaming pour des interactions plus rapides
Par défaut, le modèle renvoie une réponse une fois l'ensemble du processus de génération terminé. Vous pouvez obtenir des interactions plus rapides en évitant d'attendre l'intégralité du résultat, et en utilisant plutôt le traitement par flux pour gérer des résultats partiels.
L'exemple suivant montre comment implémenter la diffusion en flux continu avec la méthode generateContentStream pour générer du texte à partir d'une invite de saisie de texte et d'image.
// ...
final response = model.generateContentStream([
Content.multi([prompt, ...imageParts])
]);
await for (final chunk in response) {
print(chunk.text);
}
// ...
Vous pouvez utiliser une approche similaire pour les cas d'utilisation de la saisie de texte et du chat.
// Use streaming with text-only input
final response = model.generateContentStream(content);
// Use streaming with multi-turn conversations (like chat)
final response = chat.sendMessageStream(content);
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 aideront à vous familiariser avec l'API Gemini. Cette section décrit certains cas d'utilisation qui peuvent être considérés comme plus avancés.
Utiliser des représentations vectorielles continues
La technique de représentation vectorielle continue permet de représenter des informations sous la forme d'une liste de nombres à virgule flottante dans un tableau. Avec Gemini, vous pouvez représenter du texte (mots, phrases et blocs de texte) sous une forme vectorisée, ce qui facilite la comparaison et le contraste des représentations vectorielles continues. Par exemple, deux textes qui partagent un sujet ou un sentiment similaire doivent avoir des représentations vectorielles continues similaires, qui peuvent être identifiées à l'aide de techniques de comparaison mathématiques telles que la similarité cosinus.
Utilisez le modèle embedding-001 avec la méthode embedContent (ou la méthode batchEmbedContent) pour générer des représentations vectorielles continues. L'exemple suivant génère une représentation vectorielle continue pour une seule chaîne:
final model = GenerativeModel(model: 'embedding-001', apiKey: apiKey);
final content = Content.text('The quick brown fox jumps over the lazy dog.');
final result = await model.embedContent(content);
print(result.embedding.values);
Compter les jetons
Lorsque vous utilisez des invites longues, 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:
// For text-only input
final tokenCount = await model.countTokens(Content.text(prompt));
print('Token count: ${tokenCount.totalTokens}');
// For text-and-image input (multimodal)
final tokenCount = await model.countTokens([
Content.multi([prompt, ...imageParts])
]);
print('Token count: ${tokenCount.totalTokens}');
// For multi-turn conversations (like chat)
final prompt = Content.text(message);
final allContent = [...chat.history, prompt];
final tokenCount = await model.countTokens(allContent);
print('Token count: ${tokenCount.totalTokens}');
Options pour contrôler la génération de contenu
Vous pouvez contrôler la génération de contenu en configurant des paramètres de modèle et en utilisant des paramètres de sécurité.
Notez que la transmission de generationConfig ou safetySettings à une méthode de requête de modèle (telle que generateContent) remplace complètement l'objet de configuration portant le même nom que celui transmis dans getGenerativeModel.
Configurer les paramètres du modèle
Chaque invite que vous envoyez au modèle inclut des valeurs de paramètres 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. Apprenez-en plus sur les paramètres de modèle. La configuration est conservée pendant toute la durée de vie de votre instance de modèle.
final generationConfig = GenerationConfig(
stopSequences: ["red"],
maxOutputTokens: 200,
temperature: 0.9,
topP: 0.1,
topK: 16,
);
final model = GenerativeModel(
model: 'MODEL_NAME',
apiKey: apiKey,
generationConfig: generationConfig,
);
Utiliser les paramètres de sécurité
Vous pouvez utiliser les paramètres de sécurité pour ajuster la probabilité de recevoir des réponses pouvant être considérées comme nuisibles. Par défaut, les paramètres de sécurité bloquent le contenu ayant une probabilité moyenne et/ou élevée d'être un contenu dangereux dans toutes les dimensions. En savoir plus sur les paramètres de sécurité
Voici comment définir un paramètre de sécurité:
final safetySettings = [
SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high)
];
final model = GenerativeModel(
model: 'MODEL_NAME',
apiKey: apiKey,
safetySettings: safetySettings,
);
Vous pouvez également définir plusieurs paramètres de sécurité:
final safetySettings = [
SafetySetting(HarmCategory.harassment, HarmBlockThreshold.high),
SafetySetting(HarmCategory.hateSpeech, HarmBlockThreshold.high),
];
Étapes suivantes
La conception d'invites est le processus de création d'invites 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 invites bien structurées. Découvrez les bonnes pratiques concernant la rédaction de requêtes.
Gemini propose plusieurs variantes de modèle pour répondre aux besoins de différents cas d'utilisation, tels que les types et la complexité des entrées, les implémentations pour le chat ou d'autres tâches linguistiques de dialogue, ainsi que les contraintes de taille. Découvrez les modèles Gemini disponibles.
Gemini propose des options pour demander des augmentations de la limite de débit. La limite de débit pour les modèles Geni Pro est de 60 requêtes par minute (tr/min).