Ce tutoriel explique comment accéder à l'API Gemini directement depuis votre application Swift à l'aide du SDK Google AI Swift. Vous pouvez utiliser ce SDK si vous ne souhaitez pas travailler directement avec des API REST ou du code côté serveur (comme Python) pour accéder aux modèles Geniaux dans votre application Swift.
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 les cas d'utilisation avancés (tels que les jetons de comptage) et 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 utiliser Xcode pour développer des applications Swift.
Pour suivre ce tutoriel, assurez-vous que votre environnement de développement et votre application Swift répondent aux exigences suivantes:
- Xcode 15.0 ou version ultérieure
- Votre application Swift doit cibler iOS 15 ou version ultérieure, ou macOS 12 ou version ultérieure.
Configurer votre projet
Avant d'appeler l'API Gemini, vous devez configurer votre projet Xcode, ce qui inclut la définition de votre clé API, l'ajout du package SDK à votre projet Xcode 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
Il est vivement recommandé de ne pas vérifier une clé API dans votre système de contrôle des versions. Une autre option consiste à la stocker dans un fichier GenerativeAI-Info.plist
, puis à lire la clé API à partir du fichier .plist
. Veillez à placer ce fichier .plist
dans le dossier racine de votre application et à l'exclure du contrôle des versions.
Vous pouvez également consulter l'application exemple pour savoir comment stocker votre clé API dans un fichier .plist
.
Tous les extraits de ce tutoriel supposent que vous accédez à votre clé API à partir de ce fichier de ressource à la demande .plist
.
Ajouter le package SDK à votre projet
Pour utiliser l'API Gemini dans votre propre application Swift, ajoutez le package GoogleGenerativeAI
à votre application:
Dans Xcode, effectuez un clic droit sur votre projet dans le navigateur de projets.
Sélectionnez Add Packages (Ajouter des packages) dans le menu contextuel.
Dans la boîte de dialogue Add Packages (Ajouter des packages), collez l'URL du package dans la barre de recherche:
https://github.com/google/generative-ai-swift
Cliquez sur Add Package (Ajouter un package). Xcode va maintenant ajouter le package
GoogleGenerativeAI
à votre projet.
Initialiser le modèle génératif
Avant de pouvoir effectuer des appels d'API, vous devez initialiser le modèle génératif.
Importez le module
GoogleGenerativeAI
:import GoogleGenerativeAI
Initialisez le modèle génératif:
// Access your API key from your on-demand resource .plist file // (see "Set up your API key" above) // The Gemini 1.5 models are versatile and work with most use cases let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
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-vision
est destiné à l'entrée multimodale). Dans ce guide, les instructions pour chaque implémentation listent 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 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
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 un modèle Gemini 1.5 ou le modèle Geni 1.0 Pro avec generateContent
pour générer le texte de sortie:
import GoogleGenerativeAI
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
let prompt = "Write a story about a magic backpack."
let response = try await model.generateContent(prompt)
if let text = response.text {
print(text)
}
Générer du texte à partir d'une entrée de texte et d'image (multimodale)
Gemini fournit divers modèles capables de gérer des entrées multimodales (modèles Geni 1.5 et Gemini 1.0 Pro Vision) afin que vous puissiez saisir à la fois du texte et des images. Veillez à consulter les exigences concernant les images pour les invites.
Lorsque l'entrée de la requête comprend à la fois du texte et des images, utilisez un modèle Gemini 1.5 ou Gemini 1.0 Pro Vision avec la méthode generateContent
pour générer une sortie textuelle:
import GoogleGenerativeAI
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
let image1 = UIImage(...)
let image2 = UIImage(...)
let prompt = "What's different between these pictures?"
let response = try await model.generateContent(prompt, image1, image2)
if let text = response.text {
print(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 multitours (telle qu'un chat), utilisez un modèle Gemini 1.5 ou Genmini 1.0 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
.model
: rôle qui fournit les réponses. Ce rôle peut être utilisé lorsque vous appelezstartChat()
avec lehistory
existant.
import GoogleGenerativeAI
let config = GenerationConfig(
maxOutputTokens: 100
)
// The Gemini 1.5 models are versatile and work with multi-turn conversations (like chat)
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
name: "gemini-1.5-flash",
apiKey: APIKey.default,
generationConfig: config
)
let history = [
ModelContent(role: "user", parts: "Hello, I have 2 dogs in my house."),
ModelContent(role: "model", parts: "Great to meet you. What would you like to know?"),
]
// Initialize the chat
let chat = model.startChat(history: history)
let response = try await chat.sendMessage("How many paws are in my house?")
if let text = response.text {
print(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.
import GoogleGenerativeAI
// The Gemini 1.5 models are versatile and work with both text-only and multimodal prompts
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
let image1 = UIImage(named: "")!
let image2 = UIImage(named: "")!
let prompt = "What's different between these pictures?"
var fullResponse = ""
let contentStream = model.generateContentStream(prompt, image1, image2)
for try await chunk in contentStream {
if let text = chunk.text {
print(text)
fullResponse += text
}
}
print(fullResponse)
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
let contentStream = model.generateContentStream(prompt)
// Use streaming with multi-turn conversations (like chat)
let responseStream = chat.sendMessageStream(message)
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.
Appel de fonction
Les appels de fonctions vous permettent 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 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
let response = try await model.countTokens("Why is the sky blue?")
print(response.totalTokens)
// For text-and-image input (multi-modal)
let response = try await model.countTokens(prompt, image1, image2)
print(response.totalTokens)
// For multi-turn conversations (like chat)
let chat = model.startChat()
let history = chat.history
let message = try ModelContent(role: "user", "Why is the sky blue?")
let contents = history + [message]
let response = try await model.countTokens(contents)
print(response.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é.
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.
let config = GenerationConfig(
temperature: 0.9,
topP: 0.1,
topK: 16,
maxOutputTokens: 200,
stopSequences: ["red"]
)
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
name: "gemini-1.5-flash",
apiKey: APIKey.default,
generationConfig: config
)
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é:
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
name: "gemini-1.5-flash",
apiKey: APIKey.default,
safetySettings: [
SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh)
]
)
Vous pouvez également définir plusieurs paramètres de sécurité:
let harassmentSafety = SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh)
let hateSpeechSafety = SafetySetting(harmCategory: .hateSpeech, threshold: .blockMediumAndAbove)
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
// The Gemini 1.5 models are versatile and work with most use cases
name: "gemini-1.5-flash",
apiKey: APIKey.default,
safetySettings: [harassmentSafety, hateSpeechSafety]
)
É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 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).