Samouczek wywoływania funkcji

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

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.

Modele Gemini możesz przesłać z opisami funkcji. Są to funkcje, które piszesz w języku aplikacji (czyli nie są to funkcje Google Cloud). Model może poprosić o wywołanie funkcji i odesłanie wyniku, aby ułatwić mu obsługę zapytania.

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

Przykładowy interfejs API do sterowania oświetleniem

Załóżmy, że masz podstawowy system sterowania oświetleniem z interfejsem programowania aplikacji (API) i chcesz umożliwić użytkownikom sterowanie oświetleniem za pomocą prostych żądań tekstowych. Możesz użyć funkcji wywołań funkcji, aby zinterpretować prośby użytkowników o zmianę oświetlenia i przełożyć je na wywołania interfejsu API w celu ustawienia wartości oświetlenia. Ten hipotetyczny system sterowania oświetleniem umożliwia kontrolowanie jasności światła oraz temperatury barwowej za pomocą 2 osobnych parametrów:

Dla uproszczenia ten wymyślony system oświetleniowy ma tylko 1 światło, więc użytkownik nie musi określać pomieszczenia ani lokalizacji. Oto przykładowe żądanie JSON, które możesz wysłać do interfejsu API sterowania oświetleniem, aby zmienić poziom jasności na 50% z użyciem temperatury barwowej światła dziennego:

{
  "brightness": "50",
  "colorTemperature": "daylight"
}

Ten samouczek pokazuje, jak skonfigurować wywołanie funkcji dla interfejsu Gemini API, aby zinterpretować żądania dotyczące oświetlenia i mapować je na ustawienia interfejsu API w celu sterowania wartościami jasności i temperatury kolorów.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

Zanim wywołasz Gemini API, musisz skonfigurować projekt i klucz interfejsu API.

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

Zdefiniuj funkcję interfejsu API

utworzyć funkcję, która wysyła żądanie do interfejsu API; Ta funkcja powinna być zdefiniowana w kodzie aplikacji, ale może wywoływać usługi lub interfejsy API poza nią. Interfejs Gemini API nie wywołuje tej funkcji bezpośrednio, więc możesz kontrolować, jak i kiedy ta funkcja jest wykonywana za pomocą kodu aplikacji. Dla celów demonstracyjnych ten samouczek definiuje przykładową funkcję interfejsu API, która zwraca żądane wartości oświetlenia:

func setLightValues(brightness: String,
                    colorTemp: String) -> JSONObject {
  // This mock API returns the requested lighting values
  return [
    "brightness": .string(brightness),
    "colorTemperature": .string(colorTemp)
  ]
}

Utwórz deklaracje funkcji

Utwórz deklarację funkcji, którą przekażesz do modelu generatywnego. Deklarując funkcję do użycia przez model, podaj jak najwięcej szczegółów w opisach funkcji i parametrów. Na podstawie tych informacji model generatywny określa, którą funkcję wybrać i jak podać wartości dla parametrów w wywołaniu funkcji. Ten kod pokazuje, jak zadeklarować funkcję sterowania oświetleniem:

let controlLightFunctionDeclaration = FunctionDeclaration(
  name: "controlLight",
  description: "Set the brightness and color temperature of a room light.",
  parameters: [
    "brightness": Schema(
      type: .string,
      description: "Light level from 0 to 100. Zero is off and 100 is full brightness."
    ),
    "colorTemperature": Schema(
      type: .string,
      description: "Color temperature of the light fixture which can be `daylight`, `cool` or `warm`."
    ),
  ],
  requiredParameters: ["brightness", "colorTemperature"]
)

Deklarowanie funkcji podczas inicjowania modelu

Jeśli chcesz używać wywołań funkcji z modelem, musisz podczas inicjowania obiektu modelu przesłać deklaracje funkcji. Aby zadeklarować funkcje, ustaw parametr tools modelu:

// Use a model that supports function calling, like a Gemini 1.5 model
let generativeModel = GenerativeModel(
  name: "gemini-1.5-flash",
  apiKey: apiKey,
  // Specify the function declaration.
  tools: [Tool(functionDeclarations: [controlLightFunctionDeclaration])]
)

Wygeneruj wywołanie funkcji

Po zainicjowaniu modelu z deklaracjami funkcji możesz wyświetlić prompt za pomocą zdefiniowanej funkcji. Wywoływać funkcji należy używać za pomocą promptów na czacie (sendMessage()), ponieważ wywołanie funkcji zwykle korzysta z kontekstu poprzednich promptów i odpowiedzi.

let chat = generativeModel.startChat()

let prompt = "Dim the lights so the room feels cozy and warm."

// 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 == "controlLight" else {
  fatalError("Unexpected function called: \(functionCall.name)")
}
// Verify that the names and types of the parameters match the declaration
guard case let .string(brightness) = functionCall.args["brightness"] else {
  fatalError("Missing argument: brightness")
}
guard case let .string(colorTemp) = functionCall.args["colorTemperature"] else {
  fatalError("Missing argument: colorTemperature")
}

// Call the hypothetical API
let apiResponse = setLightValues(brightness: brightness, colorTemperature: colorTemp)

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