Anleitung: Erste Schritte mit der Gemini API

Python Node.js Web REST Go Dart (Flutter) Android Swift

In diesem Tutorial wird gezeigt, wie du mit dem Google AI Swift SDK direkt aus deiner Swift-App auf die Gemini API zugreifen kannst. Sie können dieses SDK verwenden, wenn Sie nicht direkt mit REST APIs oder serverseitigem Code (wie 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 einschließlich API-Schlüssel einrichten
• Text aus reiner Texteingabe generieren
• Text aus Text- und Bildeingaben (multimodal) generieren
• Unterhaltungen mit mehreren Themen erstellen (Chat)
• Streaming für schnellere Interaktionen verwenden

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

Voraussetzungen

In dieser Anleitung wird davon ausgegangen, dass Sie mit Xcode zur Entwicklung von Swift-Apps vertraut sind.

Damit du diese Anleitung abschließen kannst, müssen deine Entwicklungsumgebung und deine 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 gehört auch das Einrichten des API-Schlüssels, das Hinzufügen des SDK-Pakets zu Ihrem Xcode-Projekt und das Initialisieren des Modells.

API-Schlüssel einrichten

Zur Verwendung der Gemini API benötigen Sie einen API-Schlüssel. Falls noch nicht geschehen, erstellen Sie einen Schlüssel in Google AI Studio.

API-Schlüssel anfordern

API-Schlüssel sichern

Es wird dringend empfohlen, keinen API-Schlüssel in das Versionsverwaltungssystem einzuchecken. Eine alternative Möglichkeit besteht darin, den API-Schlüssel in einer GenerativeAI-Info.plist-Datei zu speichern und dann aus der Datei .plist zu lesen. Legen Sie die Datei .plist im Stammordner Ihrer Anwendung ab und schließen Sie sie aus 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 On-Demand-Ressourcendatei .plist auf Ihren API-Schlüssel zugreifen.

SDK-Paket zu 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 im Projektnavigator mit der rechten Maustaste auf Ihr Projekt.

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

3. Fügen Sie im Dialogfeld 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 jetzt 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)
   // The Gemini 1.5 models are versatile and work with most use cases
   let model = GenerativeModel(name: "gemini-1.5-flash", apiKey: APIKey.default)
   

Beachten Sie beim Angeben eines Modells Folgendes:

• Verwenden Sie ein Modell, das für Ihren Anwendungsfall spezifisch ist (z. B. gemini-1.5-flash für eine multimodale Eingabe). In diesem Leitfaden wird in den Anleitungen für jede Implementierung das empfohlene Modell für jeden Anwendungsfall aufgeführt.

Gängige Anwendungsfälle implementieren

Nachdem Ihr Projekt nun eingerichtet ist, können Sie ausprobieren, wie Sie mit der Gemini API verschiedene Anwendungsfälle implementieren:

• Text aus reiner Texteingabe generieren
• Text aus Text- und Bildeingaben (multimodal) generieren
• Unterhaltungen mit mehreren Themen erstellen (Chat)
• Streaming für schnellere Interaktionen verwenden

Text aus reiner Texteingabe generieren

Wenn der Prompt nur Text enthält, verwenden Sie ein Gemini 1.5-Modell oder das Gemini 1.0 Pro-Modell mit generateContent, um die Textausgabe zu generieren:

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

Text aus Text- und Bildeingabe generieren (multimodal)

Gemini bietet verschiedene Modelle, die multimodale Eingaben verarbeiten können (Gemini 1.5-Modelle), sodass Sie sowohl Text als auch Bilder eingeben können. Lies dir auch die Anforderungen an Bilder für Prompts durch.

Wenn die Prompt-Eingabe sowohl Text als auch Bilder enthält, verwenden Sie ein Gemini 1.5-Modell mit der Methode generateContent, um eine Textausgabe zu generieren:

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

Multi-Turn Conversations erstellen (Chat)

Mit Gemini kannst du Unterhaltungen im freien Format über mehrere Runden hinweg führen. Das SDK vereinfacht den Vorgang, da es den Status der Unterhaltung verwaltet. Im Gegensatz zu generateContent müssen Sie den Unterhaltungsverlauf also nicht selbst speichern.

Wenn Sie eine mehrsprachige Unterhaltung (z. B. Chat) erstellen möchten, verwenden Sie ein Gemini 1.5-Modell oder Gemini 1.0 Pro und initialisieren Sie den Chat, indem Sie startChat() aufrufen. 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 dem Inhalt einer Unterhaltung zugeordnet sind:

• user: Die Rolle, die die Aufforderungen bereitstellt. Dies ist der Standardwert für sendMessage-Aufrufe.

• model: Die Rolle, die die Antworten bereitstellt. Diese Rolle kann beim Aufrufen von startChat() mit vorhandenem history verwendet werden.

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

Streaming für schnellere Interaktionen nutzen

Standardmäßig gibt das Modell nach Abschluss des gesamten Generierungsprozesses eine Antwort zurück. Sie können schnellere Interaktionen erzielen, wenn Sie nicht auf das gesamte Ergebnis warten, sondern stattdessen Streaming verwenden, um Teilergebnisse zu verarbeiten.

Das folgende Beispiel zeigt, wie Streaming mit der Methode generateContentStream implementiert wird, um Text über einen Text-und-Bild-Eingabe-Prompt zu generieren.

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)

Sie können einen ähnlichen Ansatz für reine Texteingabe und Chat-Anwendungsfälle verwenden.

// 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 dieses Tutorials beschriebenen gängigen Anwendungsfälle helfen Ihnen, sich mit der Verwendung der Gemini API vertraut zu machen. In diesem Abschnitt werden einige Anwendungsfälle beschrieben, die möglicherweise als komplexer gelten.

Funktionsaufrufe

Funktionsaufrufe erleichtern es Ihnen, Ausgaben strukturierter Daten aus generativen Modellen zu erhalten. Sie können diese Ausgaben dann verwenden, um andere APIs aufzurufen und die relevanten Antwortdaten an das Modell zurückzugeben. Mit anderen Worten: Funktionsaufrufe helfen Ihnen, generative Modelle mit externen Systemen zu verbinden, damit die generierten Inhalte aktuelle und genaue Informationen enthalten. Weitere Informationen finden Sie in der Anleitung zu Funktionsaufrufen.

Anzahl der Tokens

Bei langen Prompts 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 = try 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 Inhaltserstellung

Sie können das Generieren von Inhalten 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 gesamte 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(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  generationConfig: config
)

Sicherheitseinstellungen verwenden

Mit Sicherheitseinstellungen kannst du die Wahrscheinlichkeit anpassen, dass du Antworten erhältst, die als schädlich eingestuft werden können. Standardmäßig blockieren Sicherheitseinstellungen Inhalte mit mittlerer und/oder hoher Wahrscheinlichkeit, die als unsicher eingestuft werden, in allen Dimensionen. Weitere Informationen zu den 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(
  // 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)
  ]
)

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(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  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 Modellvarianten für verschiedene Anwendungsfälle, z. B. Eingabetypen und -komplexität, Implementierungen für Chat- oder andere Sprachaufgaben für Chats und Größenbeschränkungen. Weitere Informationen zu den verfügbaren Gemini-Modellen