Samouczek: wywoływanie funkcji za pomocą interfejsu Gemini API

Python Node.js Go Dart (Flutter) Android Swift Internet

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.

Modelom Gemini możesz podawać opisy funkcji. Są to funkcje, które piszesz w języku swojej aplikacji (nie należą one do Google Cloud Functions). Model może poprosić Cię o wywołanie funkcji i odesłanie wyniku, aby model mógł lepiej obsłużyć zapytanie.

Więcej informacji znajdziesz w wprowadzeniu do wywoływania funkcji.

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.

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

Konfigurowanie wywołania funkcji

W tym samouczku model będzie wchodzić w interakcje z hipotetycznym interfejsem API wymiany walut, który obsługuje te parametry:

Przykładowe żądanie do interfejsu API

{
  "currencyFrom": "USD",
  "currencyTo": "SEK"
}

Przykładowa odpowiedź interfejsu API

{
  "base": "USD",
  "rates": {"SEK": 0.091}
}

Krok 1. Utwórz funkcję, która wysyła żądanie do interfejsu API

Zacznij od utworzenia funkcji, która wysyła żądanie do interfejsu API.

Na potrzeby demonstracji w tym samouczku zamiast wysyłania rzeczywistego żądania do interfejsu API będziesz zwracać wartości zakodowane na stałe w tym samym formacie, w jakim jest zwrócony interfejs API.

func makeAPIRequest(currencyFrom: String,
                    currencyTo: String) -> JSONObject {
  // This hypothetical API returns a JSON such as:
  // {"base":"USD","rates":{"SEK": 0.091}}
  return [
    "base": .string(currencyFrom),
    "rates": .object([currencyTo: .number(0.091)]),
  ]
}

Krok 2. Utwórz deklarację funkcji

Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego (następny krok tego samouczka).

W opisach funkcji i parametrów podaj jak najwięcej szczegółów. Model generatywny wykorzystuje te informacje do określenia, którą funkcję wybrać i jak podać wartości parametrów w jej wywołaniu.

let getExchangeRate = FunctionDeclaration(
  name: "getExchangeRate",
  description: "Get the exchange rate for currencies between countries",
  parameters: [
    "currencyFrom": Schema(
      type: .string,
      description: "The currency to convert from."
    ),
    "currencyTo": Schema(
      type: .string,
      description: "The currency to convert to."
    ),
  ],
  requiredParameters: ["currencyFrom", "currencyTo"]
)

Krok 3. Określ deklarację funkcji podczas inicjowania modelu

Podczas inicjowania modelu generatywnego określ deklarację funkcji, ustawiając parametr tools modelu:

// Use a model that supports function calling, like Gemini 1.0 Pro.
// See "Supported models" in the "Introduction to function calling" page.
let generativeModel = GenerativeModel(
  name: "gemini-1.0-pro",
  apiKey: apiKey,
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [getExchangeRate])]
)

Krok 4. Wygeneruj wywołanie funkcji

Teraz możesz wywołać dla modelu zdefiniowaną funkcję.

Zalecanym sposobem korzystania z wywołań funkcji jest korzystanie z interfejsu czatu, ponieważ wywołania funkcji dobrze pasują do wieloetapowej struktury czatu.

let chat = generativeModel.startChat()

let prompt = "How much is 50 US dollars worth in Swedish krona?"

// Send the message to the generative model
let response1 = try await chat.sendMessage(prompt)

// Check if the model responded with a function call
guard let functionCall = response1.functionCalls.first else {
  fatalError("Model did not respond with a function call.")
}
// Print an error if the returned function was not declared
guard functionCall.name == "getExchangeRate" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(currencyFrom) = functionCall.args["currencyFrom"] else {
  fatalError("Missing argument: currencyFrom")
}
guard case let .string(currencyTo) = functionCall.args["currencyTo"] else {
  fatalError("Missing argument: currencyTo")
}

// Call the hypothetical API
let apiResponse = makeAPIRequest(currencyFrom: currencyFrom, currencyTo: currencyTo)

// Send the API response back to the model so it can generate a text response that can be
// displayed to the user.
let response = try await chat.sendMessage([ModelContent(
  role: "function",
  parts: [.functionResponse(FunctionResponse(
    name: functionCall.name,
    response: apiResponse
  ))]
)])

// Log the text response.
guard let modelResponse = response.text else {
  fatalError("Model did not respond with text.")
}
print(modelResponse)