Tutorial: inizia a utilizzare l'API Gemini

Python Node.js Web REST Vai Dart (flutter) Android Swift

Questo tutorial mostra come accedere all'API Gemini direttamente dal tuo App Swift che utilizza l'SDK Swift per l'IA di Google. Puoi usare questo SDK se non vuoi di lavorare direttamente con le API REST o con il codice lato server (come Python) per accedere Gemini nell'app Swift.

In questo tutorial imparerai a:

• Configurare il progetto, inclusa la chiave API
• Generare testo da input di solo testo
• Genera testo da input di testo e immagine (multimodale)
• Creare conversazioni in più passaggi (chat)
• Usa la modalità flusso per interazioni più rapide

Inoltre, questo tutorial contiene sezioni sui casi d'uso avanzati (come token di conteggio) nonché opzioni per il controllo della generazione di contenuti.

Prerequisiti

Questo tutorial presuppone che tu conosca bene Xcode per sviluppare Swift app.

Per completare questo tutorial, assicurati che il tuo ambiente di sviluppo L'app Swift soddisfa i seguenti requisiti:

• Xcode 15.0 o successivo
• 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 tuo progetto Xcode, include la configurazione della chiave API, l'aggiunta del pacchetto SDK al progetto Xcode, e inizializzare il modello.

Configura la chiave API

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

Ottenere una chiave API

Proteggi la chiave API

Ti consigliamo vivamente di non controllare una chiave API per conoscere la tua versione di controllo dei dati. Un'opzione alternativa è memorizzarla in un GenerativeAI-Info.plist, quindi leggi la chiave API dal file .plist . Assicurati di aver inserito questo file .plist nella cartella principale della tua app e per escluderlo 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 consultare app di esempio per scoprire come archiviare 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 risorse on demand.

Aggiungi il pacchetto SDK al progetto

Per usare l'API Gemini nella tua app Swift, aggiungi GoogleGenerativeAI pacchetto per la tua 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 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)
   // The Gemini 1.5 models are versatile and work with most use cases
   let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
   

Quando specifichi un modello, tieni presente quanto segue:

• Utilizza un modello specifico per il tuo caso d'uso (ad esempio gemini-1.5-flash per l'input multimodale). In questa guida, le istruzioni per ogni di implementazione, elencare il modello consigliato per ogni caso d'uso.

Implementare casi d'uso comuni

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

• Generare testo da input di solo testo
• Genera testo da input di testo e immagine (multimodale)
• Creare conversazioni in più passaggi (chat)
• Usa la modalità flusso per interazioni più rapide

Genera testo da input di solo testo

Quando l'input del prompt include solo testo, utilizza un modello Gemini 1.5 oppure Modello Gemini 1.0 Pro con generateContent per generare output di testo:

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

Genera testo da input di testo e immagine (multimodale)

Gemini fornisce vari modelli in grado di gestire l'input multimodale (modelli Gemini 1.5) in modo da poter inserire sia testo e immagini. Assicurati di esaminare requisiti relativi alle immagini per i prompt.

Quando l'input del prompt include sia testo che immagini, utilizza un modello Gemini 1.5 con il metodo generateContent per generare un output di testo:

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

Creare conversazioni in più passaggi (chat)

Con Gemini, puoi creare conversazioni in formato libero in più turni. La SDK semplifica il processo gestendo lo stato della conversazione. con generateContent, non è necessario memorizzare la cronologia delle conversazioni per te.

Per creare una conversazione in più passaggi (come la chat), utilizza un modello Gemini 1.5 oppure la Gemini 1.0 Pro e inizializzare la chat chiamando startChat(). Quindi utilizza sendMessage() per inviare un nuovo messaggio per l'utente, a cui verrà aggiunto anche il codice e la risposta alla cronologia chat.

Esistono due possibili opzioni per role associate ai contenuti in un conversazione:

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

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

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

Usa la modalità flusso per interazioni più rapide

Per impostazione predefinita, il modello restituisce una risposta dopo aver completato l'intera generazione e il processo di sviluppo. Puoi ottenere interazioni più rapide non aspettando l'intero e usare la modalità flusso per gestire i risultati parziali.

L'esempio seguente mostra come implementare i flussi di dati con Metodo generateContentStream per generare testo da un input di testo e immagine .

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)

Puoi utilizzare un approccio simile per casi d'uso di input 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 aiutano a utilizzare l'API Gemini. Questa sezione descrive alcuni e i casi d'uso che possono essere considerati più avanzati.

Chiamate di funzione

La chiamata di funzione semplifica l'ottenimento di output di dati strutturati da e modelli generativi. Puoi quindi utilizzare questi output per chiamare altre API e restituire i dati di risposta pertinenti al modello. In altre parole, la chiamata di funzione colleghi modelli generativi a sistemi esterni in modo che i contenuti generati includa le informazioni più aggiornate e accurate. Scopri di più nel tutorial sulle chiamate di funzione.

Conta token

Quando utilizzi prompt lunghi, potrebbe essere utile contare i token prima di inviare 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 = try 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 impostazioni di sicurezza.

Configura i parametri del modello

Ogni richiesta inviata al modello include valori parametro che controllano come il modello genera una risposta. Il modello può generare risultati diversi diversi valori parametro. Scopri di più su 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(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  generationConfig: config
)

Utilizzare le impostazioni di sicurezza

Puoi utilizzare le impostazioni di sicurezza per regolare la probabilità di ricevere risposte che potrebbero essere considerati dannosi. Per impostazione predefinita, le impostazioni di sicurezza bloccano i contenuti con mezzo e/o con probabilità elevata di essere contenuti non sicuri in tutte le dimensioni. Impara 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(
  // 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)
  ]
)

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(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
    safetySettings: [harassmentSafety, hateSpeechSafety]
)

Passaggi successivi

• La progettazione dei prompt è il processo di creazione dei prompt che suscitano l'interesse desiderato la risposta dai modelli linguistici. Scrivere prompt ben strutturati è fondamentale parte della garanzia di risposte accurate e di alta qualità da un modello linguistico. Scopri le best practice per la scrittura di prompt.

• Gemini offre diverse varianti di modelli per soddisfare le esigenze di usi diversi come la complessità e i tipi di input, le implementazioni per la chat o altri le attività legate al linguaggio delle finestre di dialogo e i vincoli di dimensione. Scopri di più sui modelli Gemini disponibili.