Erste Schritte mit der Gemini API in Swift-Apps

In dieser Anleitung wird gezeigt, wie Sie mit dem Google AI Swift SDK direkt über Ihre Swift-App auf die Gemini API zugreifen. Sie können dieses SDK verwenden, wenn Sie nicht direkt mit REST APIs oder serverseitigem Code (z. B. Python) für den Zugriff auf Gemini-Modelle in Ihrer Swift-App arbeiten möchten.

In dieser Anleitung erfahren Sie, wie Sie Folgendes tun:

• Projekt einrichten, einschließlich API-Schlüssel
• Text aus reiner Texteingabe generieren
• Text aus Text- und Bildeingabe generieren (multimodal)
• Multi-Turn Conversations (Chat)
• Schnellere Interaktionen dank Streaming

Darüber hinaus enthält diese Anleitung Abschnitte zu erweiterten Anwendungsfällen (z. B. Tokens zählen) sowie Optionen zum Steuern der Generierung von Inhalten.

Voraussetzungen

In dieser Anleitung wird davon ausgegangen, dass Sie mit der Verwendung von Xcode zum Entwickeln von Swift-Apps vertraut sind.

Achten Sie beim Durcharbeiten dieser Anleitung darauf, dass Ihre Entwicklungsumgebung und Swift-Anwendung die folgenden Anforderungen erfüllen:

• Xcode 15.0 oder höher
• Ihre Swift-App muss auf iOS 15 oder höher bzw. macOS 12 oder höher ausgerichtet sein.

Projekt einrichten

Bevor Sie die Gemini API aufrufen, müssen Sie Ihr Xcode-Projekt einrichten. Dazu müssen Sie Ihren API-Schlüssel einrichten, dem Xcode-Projekt das SDK-Paket hinzufügen und das Modell initialisieren.

API-Schlüssel einrichten

Sie benötigen einen API-Schlüssel, um die Gemini API zu verwenden. Erstellen Sie einen Schlüssel in Google AI Studio, falls noch nicht geschehen.

API-Schlüssel anfordern

API-Schlüssel sichern

Wir empfehlen dringend, einen API-Schlüssel nicht in Ihr Versionsverwaltungssystem einzuchecken. Eine alternative Option besteht darin, den API-Schlüssel in der Datei GenerativeAI-Info.plist zu speichern und dann aus der Datei .plist zu lesen. Legen Sie diese .plist-Datei in den Stammordner Ihrer Anwendung ab und schließen Sie sie von der Versionsverwaltung aus.

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

Sie können sich auch die Beispiel-App ansehen, um zu erfahren, wie Sie Ihren API-Schlüssel in einer .plist-Datei speichern.

Bei allen Snippets in dieser Anleitung wird davon ausgegangen, dass Sie über die .plist-Datei der On-Demand-Ressource auf Ihren API-Schlüssel zugreifen.

SDK-Paket zum Projekt hinzufügen

Wenn Sie die Gemini API in Ihrer eigenen Swift-App verwenden möchten, fügen Sie Ihrer App das Paket GoogleGenerativeAI hinzu:

1. Klicken Sie in Xcode in der Projektnavigation mit der rechten Maustaste auf Ihr Projekt.

2. Wählen Sie im Kontextmenü Pakete hinzufügen aus.

3. Fügen Sie im Dialogfeld Add Packages (Pakete hinzufügen) die Paket-URL in die Suchleiste ein:

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

4. Klicken Sie auf Paket hinzufügen. Xcode fügt Ihrem Projekt nun das Paket GoogleGenerativeAI hinzu.

Generatives Modell initialisieren

Bevor Sie API-Aufrufe ausführen können, müssen Sie das generative Modell initialisieren.

1. Importieren Sie das Modul GoogleGenerativeAI:

   import GoogleGenerativeAI
   

2. Initialisieren Sie das generative Modell:

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

Beachten Sie bei der Angabe eines Modells Folgendes:

• Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B. gemini-pro-vision ist für die multimodale Eingabe vorgesehen). In diesem Leitfaden ist in den Anleitungen für jede Implementierung das empfohlene Modell für den jeweiligen Anwendungsfall aufgeführt.

Gängige Anwendungsfälle implementieren

Nachdem Ihr Projekt nun eingerichtet ist, können Sie die Verwendung der Gemini API zum Implementieren verschiedener Anwendungsfälle kennenlernen:

• Text aus reiner Texteingabe generieren
• Text aus Text- und Bildeingabe generieren (multimodal)
• Multi-Turn Conversations (Chat)
• Schnellere Interaktionen dank Streaming

Text aus reiner Texteingabe generieren

Wenn die Eingabe nur Text enthält, verwenden Sie das Modell gemini-pro mit der Methode generateContent, um eine Textausgabe zu generieren:

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

Text aus Text- und Bildeingabe generieren (multimodal)

Gemini bietet ein multimodales Modell (gemini-pro-vision), sodass Sie sowohl Text als auch Bilder eingeben können. Sieh dir die Anforderungen an Bilder für Prompts an.

Wenn die Eingabe der Aufforderung sowohl Text als auch Bilder enthält, verwenden Sie das Modell gemini-pro-vision mit der Methode generateContent, um die Textausgabe zu generieren:

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

Multi-Turn Conversations (Chat)

Mit Gemini können Sie frei formulierte Unterhaltungen über mehrere Runden hinweg erstellen. Das SDK vereinfacht den Prozess, indem es den Status der Unterhaltung verwaltet. Im Gegensatz zu generateContent müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.

Verwenden Sie das Modell gemini-pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen, um eine Unterhaltung mit mehreren Themen (z. B. Chat) zu erstellen. Verwenden Sie dann sendMessage(), um eine neue Nutzernachricht zu senden. Dadurch werden auch die Nachricht und die Antwort an das Chatprotokoll angehängt.

Es gibt zwei mögliche Optionen für role, die mit dem Inhalt einer Unterhaltung verknüpft sind:

• user: die Rolle, die die Prompts bereitstellt. Dieser Wert ist der Standardwert für sendMessage-Aufrufe.

• model: die Rolle, die die Antworten bereitstellt. Diese Rolle kann verwendet werden, wenn startChat() mit vorhandenem history aufgerufen wird.

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

Streaming für schnellere Interaktionen

Standardmäßig gibt das Modell eine Antwort zurück, nachdem der gesamte Generierungsprozess abgeschlossen ist. Sie können Interaktionen beschleunigen, indem Sie nicht auf das gesamte Ergebnis warten und stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Sie Streaming mit der Methode generateContentStream implementieren, um Text aus einer Eingabeaufforderung für Text und Bilder zu generieren.

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)

Ein ähnlicher Ansatz kann für reine Texteingaben und Chats verwendet werden.

// Use streaming with text-only input
let contentStream = model.generateContentStream(prompt)

// Use streaming with multi-turn conversations (like chat)
let responseStream = chat.sendMessageStream(message)

Erweiterte Anwendungsfälle implementieren

Die im vorherigen Abschnitt dieser Anleitung beschriebenen häufigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die als komplexer gelten.

Anzahl der Tokens

Bei der Verwendung langer Aufforderungen kann es hilfreich sein, Tokens zu zählen, bevor Inhalte an das Modell gesendet werden. Die folgenden Beispiele zeigen, wie countTokens() für verschiedene Anwendungsfälle verwendet wird:

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

Optionen zum Steuern der Inhaltsgenerierung

Sie können die Inhaltsgenerierung steuern, indem Sie Modellparameter konfigurieren und Sicherheitseinstellungen verwenden.

Modellparameter konfigurieren

Jede Aufforderung, die Sie an das Modell senden, enthält Parameterwerte, die steuern, wie das Modell eine Antwort generiert. Das Modell kann für verschiedene Parameterwerte unterschiedliche Ergebnisse generieren. Weitere Informationen zu Modellparametern Die Konfiguration wird für die Lebensdauer der Modellinstanz beibehalten.

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
)

Sicherheitseinstellungen verwenden

In den Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden könnten. Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit werden standardmäßig durch Sicherheitseinstellungen in allen Dimensionen blockiert. Weitere Informationen zu Sicherheitseinstellungen

So legen Sie eine Sicherheitseinstellung fest:

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

Sie können auch mehrere Sicherheitseinstellungen festlegen:

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

Nächste Schritte

• Beim Prompt-Design werden Aufforderungen erstellt, die die gewünschte Antwort aus Sprachmodellen auslösen. Gut strukturierte Eingabeaufforderungen sind wichtig, um genaue, hochwertige Antworten aus einem Sprachmodell zu gewährleisten. Best Practices für das Schreiben von Prompts

• Gemini bietet verschiedene Modellvariationen, um den Anforderungen verschiedener Anwendungsfälle gerecht zu werden, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Dialogsprachaufgaben sowie Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen

• Gemini bietet Optionen zum Anfordern von Erhöhungen der Ratenbegrenzung. Das Ratenlimit für Gemini Pro-Modelle beträgt 60 Anfragen pro Minute (RPM).