Tutoriel: Premiers pas avec l'API Gemini

<ph type="x-smartling-placeholder"></ph> Python Node.js Web REST Go Dart (Flutter) Android Swift

Ce tutoriel explique comment accéder à l'API Gemini directement depuis votre Application Swift utilisant le SDK Swift de Google AI. Vous pouvez utiliser ce SDK si vous ne voulez pas pour travailler directement avec les API REST ou avec du code côté serveur (comme Python) pour accéder des modèles Gemini 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 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 compter les jetons), ainsi que des options 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 Swift applications.

Pour suivre ce tutoriel, assurez-vous que votre environnement de développement et L'appli Swift répond 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, qui vous devez configurer votre clé API, ajouter le package SDK à votre projet Xcode, et initialiser le 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. Vous pouvez aussi le stocker dans un GenerativeAI-Info.plist, puis lire la clé API à partir du fichier .plist. . Veillez à placer ce fichier .plist dans le dossier racine de votre application. l'exclure du contrôle des versions.

enum APIKey {
  // Fetch the API key from `GenerativeAI-Info.plist`
  static var `default`: String {
    guard let filePath = Bundle.main.path(forResource: "GenerativeAI-Info", ofType: "plist")
    else {
      fatalError("Couldn't find file 'GenerativeAI-Info.plist'.")
    }
    let plist = NSDictionary(contentsOfFile: filePath)
    guard let value = plist?.object(forKey: "API_KEY") as? String else {
      fatalError("Couldn't find key 'API_KEY' in 'GenerativeAI-Info.plist'.")
    }
    if value.starts(with: "_") {
      fatalError(
        "Follow the instructions at https://ai.google.dev/tutorials/setup to get an API key."
      )
    }
    return value
  }
}

Vous pouvez également consulter les application exemple pour savoir comment stocker votre clé API dans un fichier .plist.

Tous les extraits de ce tutoriel partent du principe que vous accédez à votre clé API à partir de ce fichier .plist de ressources à la demande.

Ajouter le package SDK à votre projet

Pour utiliser l'API Gemini dans votre propre application Swift, ajoutez GoogleGenerativeAI package à votre application:

1. Dans Xcode, effectuez un clic droit sur votre projet dans le navigateur de projets.

2. Sélectionnez Ajouter des packages dans le menu contextuel.

3. 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
   

4. Cliquez sur 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.

1. Importez le module GoogleGenerativeAI:

   import GoogleGenerativeAI
   

2. 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-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
• 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 la Modèle Gemini 1.0 Pro avec 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 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 texte et image (multimodal)

Gemini fournit différents modèles pouvant gérer la saisie multimodale (modèles Gemini 1.5) afin que vous puissiez saisir à la fois du texte et des images. N'oubliez pas de consulter 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 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)
}

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

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 à 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 entrée texte et image requête.

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 saisie textuelle uniquement et de 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 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:

// 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 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. La configuration est conservée pendant 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é 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:

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

É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