Inizia a utilizzare l'API Gemini nelle app Swift

Questo tutorial mostra come accedere all'API Gemini direttamente dalla tua app Swift utilizzando l'SDK Swift per l'IA di Google. Puoi utilizzare questo SDK se non vuoi lavorare direttamente con le API REST o con il codice lato server (come Python) per accedere ai modelli Gemini nella tua app Swift.

In questo tutorial imparerai a:

• Configurare il progetto, inclusa la chiave API
• Generare testo da un input di solo testo
• Generare testo da input di testo e immagini (multimodale)
• Creare conversazioni a turni multipli (chat)
• Usa i flussi di dati per interazioni più rapide

Inoltre, questo tutorial contiene sezioni sui casi d'uso avanzati (come conteggio dei token) e opzioni per controllare la generazione di contenuti.

Prerequisiti

Questo tutorial presuppone che tu abbia familiarità con l'uso di Xcode per sviluppare app Swift.

Per completare questo tutorial, assicurati che l'ambiente di sviluppo e l'app Swift soddisfino i seguenti requisiti:

• Xcode 15.0 o versioni successive
• L'app Swift deve avere come target iOS 15 o versioni successive oppure macOS 12 o versioni successive.

Configura il progetto

Prima di chiamare l'API Gemini, devi configurare il progetto Xcode, che include la configurazione della chiave API, l'aggiunta del pacchetto SDK al progetto Xcode e l'inizializzazione del modello.

Configura la chiave API

Per utilizzare l'API Gemini, hai bisogno di una chiave API. Se non ne hai già una, crea una chiave in Google AI Studio.

Ottenere una chiave API

Proteggi la chiave API

Ti consigliamo vivamente di non controllare una chiave API nel tuo sistema di controllo della versione. Un'opzione alternativa è archiviarla in un file GenerativeAI-Info.plist, quindi leggere la chiave API dal file .plist. Assicurati di inserire questo file .plist nella cartella principale dell'app ed escludilo dal controllo della versione.

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
  }
}

Puoi anche esaminare l'app di esempio per scoprire come memorizzare la chiave API in un file .plist.

Tutti gli snippet in questo tutorial presuppongono che tu stia accedendo alla chiave API da questo file .plist di risorsa on demand.

Aggiungi il pacchetto SDK al tuo progetto

Per utilizzare l'API Gemini nella tua app Swift, aggiungi il pacchetto GoogleGenerativeAI all'app:

1. In Xcode, fai clic con il tasto destro del mouse sul progetto nella barra di navigazione dei progetti.

2. Seleziona Aggiungi pacchetti dal menu contestuale.

3. Nella finestra di dialogo Aggiungi pacchetti, incolla l'URL del pacchetto nella barra di ricerca:

   https://github.com/google/generative-ai-swift
   

4. Fai clic su Aggiungi pacchetto. Xcode ora aggiungerà il pacchetto GoogleGenerativeAI al tuo progetto.

Inizializzare il modello generativo

Prima di poter effettuare chiamate API, devi inizializzare il modello generativo.

1. Importa il modulo GoogleGenerativeAI:

   import GoogleGenerativeAI
   

2. Inizializza il modello generativo:

   // Access your API key from your on-demand resource .plist file
   // (see "Set up your API key" above)
   let model = GenerativeModel(name: "MODEL_NAME", apiKey: APIKey.default)
   

Quando specifichi un modello, tieni presente quanto segue:

• Utilizza un modello specifico per il tuo caso d'uso (ad esempio, gemini-pro-vision è per l'input multimodale). All'interno di questa guida, le istruzioni per ogni implementazione elencano il modello consigliato per ogni caso d'uso.

Implementare casi d'uso comuni

Ora che il progetto è configurato, puoi esplorare l'utilizzo dell'API Gemini per implementare diversi casi d'uso:

• Generare testo da un input di solo testo
• Generare testo da input di testo e immagini (multimodale)
• Creare conversazioni a turni multipli (chat)
• Usa i flussi di dati per interazioni più rapide

Genera testo da input di solo testo

Quando l'input del prompt include solo testo, utilizza il modello gemini-pro con il metodo generateContent per generare un output di testo:

import GoogleGenerativeAI

// For text-only input, use the gemini-pro model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro", 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)
}

Genera testo da input di testo e immagini (multimodale)

Gemini fornisce un modello multimodale (gemini-pro-vision), che ti consente di inserire testo e immagini. Assicurati di rivedere i requisiti relativi alle immagini per i prompt.

Quando l'input del prompt include testo e immagini, utilizza il modello gemini-pro-vision con il metodo generateContent per generare un output di testo:

import GoogleGenerativeAI

// For text-and-image input (multimodal), use the gemini-pro-vision model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro-vision", 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)
}

Creazione di conversazioni a turni multipli (chat)

Con Gemini, puoi creare conversazioni in formato libero in più turni. L'SDK semplifica il processo gestendo lo stato della conversazione. Di conseguenza, a differenza di generateContent, non devi archiviare la cronologia della conversazione manualmente.

Per creare una conversazione a turni multipli (ad esempio la chat), utilizza il modello gemini-pro e inizializza la chat chiamando startChat(). Quindi utilizza sendMessage() per inviare un nuovo messaggio utente, che aggiungerà anche il messaggio e la risposta alla cronologia chat.

Esistono due possibili opzioni per l'elemento role associati ai contenuti di una conversazione:

• user: il ruolo che fornisce i prompt. Questo valore è il valore predefinito per le chiamate sendMessage.

• model: il ruolo che fornisce le risposte. Questo ruolo può essere utilizzato durante la chiamata a startChat() con history esistente.

import GoogleGenerativeAI

let config = GenerationConfig(
  maxOutputTokens: 100
)

// For text-only input, use the gemini-pro model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  name: "gemini-pro",
  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)
}

Usa i flussi di dati per interazioni più rapide

Per impostazione predefinita, il modello restituisce una risposta dopo aver completato l'intero processo di generazione. Puoi ottenere interazioni più rapide non aspettando l'intero risultato e utilizza invece i flussi di dati per gestire i risultati parziali.

L'esempio seguente mostra come implementare il flusso di dati con il metodo generateContentStream per generare testo da una richiesta di input di testo e immagine.

import GoogleGenerativeAI

// For text-and-image input (multimodal), use the gemini-pro-vision model
// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(name: "gemini-pro-vision", 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)

Puoi utilizzare un approccio simile per i casi d'uso di solo testo e 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)

Implementare casi d'uso avanzati

I casi d'uso comuni descritti nella sezione precedente di questo tutorial consentono di acquisire dimestichezza con l'utilizzo dell'API Gemini. In questa sezione vengono descritti alcuni casi d'uso che possono essere considerati più avanzati.

Conta token

Quando utilizzi prompt lunghi, potrebbe essere utile contare i token prima di inviare contenuti al modello. I seguenti esempi mostrano come utilizzare countTokens() per vari casi d'uso:

// 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 = ModelContent(role: "user", "Why is the sky blue?")
let contents = history + [message]
let response = try await model.countTokens(contents)
print(response.totalTokens)

Opzioni per controllare la generazione di contenuti

Puoi controllare la generazione di contenuti configurando i parametri del modello e utilizzando le impostazioni di sicurezza.

Configura i parametri del modello

Ogni prompt inviato al modello include valori parametro che controllano il modo in cui il modello genera una risposta. Il modello può generare risultati diversi a seconda dei valori parametro. Scopri di più sui parametri del modello. La configurazione viene mantenuta per tutta la durata dell'istanza del modello.

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(
  name: "MODEL_NAME",
  apiKey: APIKey.default,
  generationConfig: config
)

Usa le impostazioni di sicurezza

Puoi utilizzare le impostazioni di sicurezza per regolare la probabilità di ricevere risposte che potrebbero essere considerate dannose. Per impostazione predefinita, le impostazioni di sicurezza bloccano i contenuti con una probabilità media e/o alta di essere contenuti non sicuri in tutte le dimensioni. Scopri di più sulle Impostazioni di sicurezza.

Per configurare un'impostazione di sicurezza:

// Access your API key from your on-demand resource .plist file (see "Set up your API key" above)
let model = GenerativeModel(
  name: "MODEL_NAME",
  apiKey: APIKey.default,
  safetySettings: [
    SafetySetting(harmCategory: .harassment, threshold: .blockOnlyHigh)
  ]
)

Puoi anche configurare più di un'impostazione di sicurezza:

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(
  name: "MODEL_NAME",
  apiKey: APIKey.default,
    safetySettings: [harassmentSafety, hateSpeechSafety]
)

Passaggi successivi

• La progettazione dei prompt è il processo di creazione di prompt che generano la risposta desiderata dai modelli linguistici. Scrivere prompt ben strutturati è essenziale per garantire risposte accurate e di alta qualità da un modello linguistico. Scopri le best practice per la scrittura di prompt.

• Gemini offre diverse varianti di modello per soddisfare le esigenze di diversi casi d'uso, come complessità e tipi di input, implementazioni per chat o altre attività di linguaggio di dialogo e vincoli di dimensione. Scopri di più sui modelli Gemini disponibili.

• Gemini offre opzioni per richiedere aumenti del limite di frequenza. Il limite di frequenza per i modelli Gemini Pro è di 60 richieste al minuto (RPM).