Samouczek: pierwsze kroki z interfejsem Gemini API

Python Node.js Internet REST Go Dart (Flutter) Android 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 korzystać bezpośrednio z interfejsów API REST lub kodu po stronie serwera (np. Pythona) 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 na podstawie samego tekstu
• Generowanie tekstu na podstawie danych wejściowych z tekstem i obrazem (multimodalne)
• Tworzenie rozmów wieloetapowych (czat)
• Jak korzystać ze strumieniowania, aby przyspieszyć interakcje

Dodatkowo ten samouczek zawiera sekcje o zaawansowanych przypadkach użycia (takich jak tokeny liczenia) oraz opcje kontrolowania generowania treści.

Wymagania wstępne

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

Aby ukończyć ten samouczek, upewnij się, że Twoje środowisko programistyczne i aplikacja Swift spełniają te wymagania:

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

Konfigurowanie projektu

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

Konfigurowanie klucza interfejsu API

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

Uzyskiwanie klucza interfejsu API

Zabezpiecz klucz interfejsu API

Zdecydowanie zalecamy, aby nie sprawdzać klucza interfejsu API w systemie kontroli wersji. Możesz też zapisać go 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.

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 zasobu na żądanie.

Dodaj pakiet SDK do projektu

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

1. W Xcode kliknij prawym przyciskiem myszy projekt w nawigatorze projektów.

2. W menu kontekstowym wybierz Dodaj pakiety.

3. W oknie Dodaj pakiety wklej adres URL pakietu na pasku wyszukiwania:

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

4. Kliknij Dodaj pakiet. Xcode doda teraz do Twojego projektu pakiet GoogleGenerativeAI.

Zainicjuj model generatywny

Zanim będzie można wykonywać wywołania interfejsu API, musisz zainicjować model generatywny.

1. Zaimportuj moduł GoogleGenerativeAI:

   import GoogleGenerativeAI
   

2. Zainicjuj model generatywny:

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

Podczas określania modelu pamiętaj o tych kwestiach:

• Użyj modelu dopasowanego do Twojego przypadku użycia (np. gemini-1.5-flash służy do wprowadzania multimodalnych danych wejściowych). W tym przewodniku instrukcje dotyczące poszczególnych implementacji wskazują zalecany model w poszczególnych przypadkach użycia.

Wdrażanie typowych przypadków użycia

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

• Generowanie tekstu na podstawie samego tekstu
• Generowanie tekstu na podstawie danych wejściowych z tekstem i obrazem (multimodalne)
• Tworzenie rozmów wieloetapowych (czat)
• Jak korzystać ze strumieniowania, aby przyspieszyć interakcje

Generuj tekst na podstawie samego tekstu

Jeśli prompt zawiera tylko tekst, do wygenerowania tekstu wyjściowego użyj modelu Gemini 1.5 lub Gemini 1.0 Pro z funkcją generateContent:

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

Generuj tekst na podstawie danych wejściowych z tekstem i obrazem (multimodalny)

Gemini udostępnia różne modele, które obsługują dane wejściowe multimodalne (modele Gemini 1.5), dzięki czemu można w nich wpisywać zarówno tekst, jak i obrazy. Zapoznaj się z wymaganiami dotyczącymi obrazów w promptach.

Jeśli prompt zawiera zarówno tekst, jak i obrazy, do wygenerowania tekstu wyjściowego użyj modelu Gemini 1.5 z metodą generateContent:

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

Tworzenie rozmów wieloetapowych (czat)

Za pomocą Gemini możesz prowadzić swobodne rozmowy na różnych etapach. Pakiet SDK upraszcza ten proces, zarządzając stanem rozmowy, więc w przeciwieństwie do generateContent nie musisz samodzielnie zapisywać historii rozmowy.

Aby utworzyć rozmowę wieloetapową (np. czat), użyj modelu Gemini 1.5 lub Gemini 1.0 Pro i zainicjuj czat, dzwoniąc pod numer startChat(). Następnie użyj sendMessage(), aby wysłać nową wiadomość użytkownika. Ta wiadomość i odpowiedź zostaną też dołączone do historii czatu.

Istnieją 2 opcje pola role związane z treścią rozmowy:

• user: rola, która dostarcza prompty. Jest to wartość domyślna w przypadku wywołań funkcji sendMessage.

• model: rola, która dostarcza odpowiedzi. Tej roli można używać podczas wywoływania funkcji startChat() przy użyciu istniejącego konta history.

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

Używaj strumieniowania, aby przyspieszyć 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 użyj 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 wejściowego tekstowego i obrazu.

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)

Podobne podejście możesz zastosować w przypadkach użycia samego tekstu i czatu.

// 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 sekcji tego samouczka pomagają opanować interfejs Gemini API. W tej sekcji opisujemy niektóre przypadki użycia, które mogą być uznane za bardziej zaawansowane.

Wywoływanie funkcji

Wywołania funkcji ułatwiają uzyskiwanie danych wyjściowych uporządkowanych danych z modeli generatywnych. Następnie możesz używać tych danych wyjściowych do wywoływania innych interfejsów API i zwracania odpowiednich danych odpowiedzi do modelu. Inaczej mówiąc, wywołanie funkcji pomaga połączyć modele generatywne z systemami zewnętrznymi, aby generowane treści zawierały najbardziej aktualne i dokładne informacje. Więcej informacji znajdziesz w samouczku na temat wywoływania funkcji.

Policz tokeny

W przypadku długich promptów liczenie tokenów przed wysłaniem jakiejkolwiek treści do modelu może być przydatne. Poniższe przykłady pokazują, jak używać countTokens() w różnych przypadkach:

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

Opcje kontrolowania generowania treści

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

Skonfiguruj parametry modelu

Każdy prompt wysyłany do modelu zawiera wartości parametrów, które kontrolują sposób generowania odpowiedzi przez model. Model może generować różne wyniki w zależności od wartości parametrów. Dowiedz się więcej o parametrach modelu. Konfiguracja jest przechowywana 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(
  // The Gemini 1.5 models are versatile and work with most use cases
  name: "gemini-1.5-flash",
  apiKey: APIKey.default,
  generationConfig: config
)

Korzystanie z ustawień bezpieczeństwa

Korzystając z ustawień bezpieczeństwa, możesz dostosować prawdopodobieństwo otrzymywania odpowiedzi, które mogą być uznane za szkodliwe. Domyślnie ustawienia bezpieczeństwa blokują treści o średnim prawdopodobieństwie lub z dużym prawdopodobieństwem, ż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(
  // 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)
  ]
)

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

Co dalej

• Projektowanie promptów to proces tworzenia promptów, które wywołują pożądaną odpowiedź z modeli językowych. Napisanie dobrze uporządkowanych promptów jest niezbędną częścią gwarantowania dokładnych, wysokiej jakości odpowiedzi na podstawie modelu językowego. Poznaj sprawdzone metody pisania promptów.

• Gemini oferuje kilka wersji modelu, aby sprostać różnym przypadkom użycia, takim jak typy danych wejściowych i złożoność, implementacje czatu lub innych zadań związanych z językiem w oknie dialogowym oraz ograniczenia rozmiaru. Dowiedz się więcej o dostępnych modelach Gemini.