The Google AI Swift SDK is in public preview, which means its behavior and features could change in backward-incompatible ways. Preview releases should not be used in production.

Ta strona została przetłumaczona przez Cloud Translation API.

Pierwsze kroki z interfejsem Gemini API w aplikacjach Swift

Ten samouczek pokazuje, jak uzyskać dostęp do interfejsu Gemini API bezpośrednio z aplikacji Swift za pomocą pakietu SDK Google AI Swift. Możesz użyć tego pakietu SDK, jeśli nie chcesz pracować bezpośrednio z interfejsami API REST ani z kodem po stronie serwera (np. Python) w celu uzyskania dostępu do modeli Gemini w aplikacji Swift.

Z tego samouczka dowiesz się, jak:

Konfigurowanie projektu, w tym klucza interfejsu API
Generowanie tekstu tylko na podstawie tekstu
Generowanie tekstu na podstawie danych wejściowych typu tekst i obraz (multimodalne)
Tworzenie rozmów wieloetapowych (czat)
Korzystanie ze strumieniowania danych w celu szybszej interakcji

Poza tym samouczek zawiera sekcje dotyczące zaawansowanych przypadków użycia (np. tokenów liczących) oraz opcji kontrolowania generowania treści.

Wymagania wstępne

W tym samouczku zakładamy, że umiesz używać Xcode do tworzenia aplikacji w języku Swift.

Aby ukończyć ten samouczek, sprawdź, czy Twoje środowisko programistyczne i aplikacja Swift spełniają te wymagania:

Xcode 15.0 lub nowsza
Aplikacja Swift musi być kierowana na system iOS w wersji 15 lub nowszej albo macOS w wersji 12 lub nowszej.

Konfigurowanie projektu

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt w Xcode, który obejmuje skonfigurowanie klucza interfejsu API, dodanie pakietu SDK do projektu Xcode oraz zainicjowanie modelu.

Konfigurowanie klucza interfejsu API

Aby korzystać z interfejsu Gemini API, potrzebujesz klucza interfejsu API. Jeśli nie masz jeszcze klucza, utwórz go w Google AI Studio.

Uzyskiwanie klucza interfejsu API

Zabezpieczanie klucza interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w systemie kontroli wersji. Możesz też zapisać ją w pliku GenerativeAI-Info.plist, a potem odczytać klucz interfejsu API z pliku .plist. Pamiętaj, aby umieścić ten plik .plist w folderze głównym aplikacji i wykluczyć go z kontroli wersji.

Rozwiń, aby zobaczyć, jak zapisać klucz interfejsu API z pliku .plist i jak go odczytać

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

Możesz również zapoznać się z przykładową aplikacją, aby dowiedzieć się, jak zapisać klucz interfejsu API w pliku .plist.

Wszystkie fragmenty kodu w tym samouczku zakładają, że uzyskujesz dostęp do klucza interfejsu API z tego pliku .plist zasobów na żądanie.

Dodaj pakiet SDK do projektu

Aby używać interfejsu Gemini API we własnej aplikacji Swift, dodaj do niej pakiet GoogleGenerativeAI:

W Xcode kliknij prawym przyciskiem myszy projekt w nawigatorze projektów.
Wybierz Dodaj pakiety z menu kontekstowego.
W oknie Dodaj pakiety wklej adres URL pakietu na pasku wyszukiwania:
```
https://github.com/google/generative-ai-swift
```
Kliknij Dodaj pakiet. Xcode doda teraz pakiet GoogleGenerativeAI do projektu.

Inicjowanie modelu generatywnego

Zanim zaczniesz wywoływać interfejs API, musisz zainicjować model generatywny.

Zaimportuj moduł GoogleGenerativeAI:
```
import GoogleGenerativeAI
```

Zainicjuj model generatywny:

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

Określając model, pamiętaj o tych kwestiach:

Użyj modelu, który odpowiada Twojemu przypadkowi użycia (np. gemini-pro-vision jest używany w przypadku multimodalnych danych wejściowych). W tym przewodniku w instrukcjach dotyczących poszczególnych implementacji wymieniono model zalecany dla każdego przypadku użycia.

Uwaga: szczegółowe informacje o dostępnych modelach, w tym ich możliwości i limity częstotliwości, znajdziesz w artykule Modele Gemini. Ograniczenie liczby żądań w przypadku modeli Gemini Pro wynosi 60 żądań na minutę (RPM). Dostępne są też opcje zgłaszania prośby o zwiększenie limitu częstotliwości.

Wdrażanie typowych przypadków użycia

Po skonfigurowaniu projektu możesz zacząć korzystać z interfejsu Gemini API, aby wdrażać różne przypadki użycia:

Generowanie tekstu tylko na podstawie tekstu
Generowanie tekstu na podstawie danych wejściowych typu tekst i obraz (multimodalne)
Tworzenie rozmów wieloetapowych (czat)
Korzystanie ze strumieniowania danych w celu szybszej interakcji

Generuj tekst na podstawie samego tekstu

Jeśli dane wejściowe promptu zawierają tylko tekst, użyj modelu gemini-pro z metodą generateContent, aby wygenerować dane wyjściowe tekstowe:

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

Generuj tekst na podstawie danych wejściowych typu tekst i obraz (multimodalne)

Gemini udostępnia model multimodalny (gemini-pro-vision), który umożliwia wpisywanie zarówno tekstu, jak i obrazów. Zapoznaj się z wymaganiami dotyczącymi obrazów w promptach.

Jeśli dane wejściowe promptu zawierają zarówno tekst, jak i obrazy, do wygenerowania danych wyjściowych tekstowych użyj modelu gemini-pro-vision z metodą generateContent:

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

Tworzenie rozmów wieloetapowych (czat)

Dzięki Gemini możesz swobodnie prowadzić rozmowy w wielu etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, więc w przeciwieństwie do pakietu generateContent nie musisz samodzielnie przechowywać historii rozmowy.

Aby utworzyć rozmowę wieloetapową (taką jak czat), użyj modelu gemini-pro i zainicjuj czat, wywołując metodę startChat(). Następnie za pomocą polecenia sendMessage() możesz wysłać nową wiadomość do użytkownika, która również dołączy tę wiadomość i odpowiedź do historii czatu.

Atrybut role może być powiązany z treścią rozmowy na 2 sposoby:

user: rola, która udostępnia prompty. Jest to wartość domyślna w przypadku wywołań funkcji sendMessage.
model: rola, która udziela odpowiedzi. Tej roli można używać przy wywoływaniu funkcji startChat() za pomocą istniejącej funkcji history.

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

Strumieniowanie zapewnia szybsze interakcje

Domyślnie model zwraca odpowiedź po zakończeniu całego procesu generowania. Możesz przyspieszyć interakcje, nie czekając na cały wynik. Zamiast tego możesz używać strumieniowania do obsługi częściowych wyników.

Z przykładu poniżej dowiesz się, jak wdrożyć strumieniowanie za pomocą metody generateContentStream, aby generować tekst na podstawie promptu z tekstem i obrazem.

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)

Podobne podejście możesz zastosować w przypadkach użycia związanych tylko z tekstem i na czacie.

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

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

Wdrażanie zaawansowanych przypadków użycia

Typowe przypadki użycia opisane w poprzedniej części tego samouczka pomogą Ci zapoznać się z interfejsem Gemini API. W tej sekcji opisujemy kilka przypadków użycia, które mogą być bardziej zaawansowane.

Wywoływanie funkcji

Wywoływanie funkcji ułatwia uzyskiwanie uporządkowanych danych wyjściowych z modeli generatywnych. Następnie możesz użyć tych danych wyjściowych, aby wywoływać inne interfejsy API i zwracać odpowiednie dane odpowiedzi do modelu. Inaczej mówiąc, wywołania funkcji pomagają połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały aktualne i dokładne informacje. Więcej informacji znajdziesz w samouczku wywoływania funkcji.

Policz tokeny

W przypadku używania długich promptów warto zliczać tokeny przed wysłaniem jakiejkolwiek treści do modelu. Poniższe przykłady pokazują, jak używać właściwości countTokens() w różnych przypadkach użycia:

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

Opcje sterowania generowaniem treści

Możesz kontrolować generowanie treści, konfigurując parametry modelu i używając ustawień bezpieczeństwa.

Skonfiguruj parametry modelu

Każdy prompt, który wysyłasz do modelu, zawiera wartości parametrów, które kontrolują sposób generowania odpowiedzi przez model. Model może generować różne wyniki dla różnych wartości parametrów. Dowiedz się więcej o parametrach modelu. Konfiguracja jest zachowywana przez cały okres istnienia instancji modelu.

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
)

Korzystanie z ustawień bezpieczeństwa

Za pomocą ustawień bezpieczeństwa możesz dostosować prawdopodobieństwo otrzymania odpowiedzi, które mogą zostać uznane za szkodliwe. Ustawienia bezpieczeństwa domyślnie blokują treści o średnim lub wysokim prawdopodobieństwie, że mogą być niebezpieczne we wszystkich wymiarach. Dowiedz się więcej o ustawieniach bezpieczeństwa.

Aby skonfigurować jedno ustawienie bezpieczeństwa:

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

Możesz też skonfigurować więcej niż jedno ustawienie bezpieczeństwa:

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

Co dalej

Projektowanie promptów to proces tworzenia promptów, które wywołują pożądaną odpowiedź od modeli językowych. Tworzenie dobrze uporządkowanych promptów to klucz do zapewnienia dokładnych i wysokiej jakości odpowiedzi z modelu językowego. Poznaj sprawdzone metody pisania promptów.
Gemini oferuje kilka wersji modelu, które spełniają różne potrzeby dotyczące na przykład typów danych wejściowych i złożoności, implementacji czatu lub innych zadań związanych z językiem okna czy ograniczeń rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.
Gemini udostępnia opcje, dzięki którym możesz poprosić o zwiększenie limitu częstotliwości. Dla modeli Gemini Pro limit szybkości wynosi 60 żądań na minutę (RPM).